Argomenti della lezione

Presentazione degli autotools (1/2)

Il sistema di building GNU, altrimenti noto come autotools, consiste in una suite di programmi e utility progettati per assistere lo sviluppatore nella creazione e nella distribuzione di pacchetti di codice sorgente portabili su piattaforme UNIX-like (Linux compreso)

Gli autotools comprendono una serie di programmi tra cui:

• aclocal (tool per la raccolta di MACRO utilizzate nel progetto)
• autoconf (genera lo script configure sulla base di templates più semplici)
• automake (genera automaticamente i template per il Makefile finale)
• libtool (offre un supporto generalizzato per la compilazione di librerie)

Presentazione degli autotools (2/2)

Altri tool tipicamente usati nello sviluppo di un progetto sono:

• make (tool per l’automazione del building)
• gettext (utility per l’internazionalizzazione)
• pkg-config (gestisce metainformazioni sulle librerie installate nel sistema)
• naturalmente GCC (GNU Compiler Collection)

Flusso di lavoro con gli autotools

Perché installare da sorgenti

In generale, i repository della distribuzione (e in particolare Debian e tutte le derivate) contengono migliaia di software già pacchettizzati. Tuttavia alle volte può rendersi necessaio installare un programma direttamente compilandone i sorgenti, per una serie di ragioni:

• Il particolare programma non è disponibile
• La versione pacchettizzata dalla distribuzione è vecchia
• Il pacchetto della distribuzione ha qualche caratteristica disabilitata (ad esempio per motivi di licenza)
• Il pacchetto della distribuzione presenta qualche BUG che nel frattempo è stato corretto
• Si vuole testare una patch personale, per poi inviarla agli sviluppatori del progetto
• Semplicemente, ci si vuole mettere alla prova nella compilazione di un pacchetto

Strumenti di compilazione in ubuntu

Gli strumenti necessari per compilare da sorgente dipendono, ovviamente, dal linguaggio di programmazione usato. In generale comunque andranno precedentemente installati lo specifico compilatore e alcuni tools per la gestione delle librerie e delle dipendednze del codice.

Per quanto rigurada i programmi scritti in C/C++, Debian (e Ubuntu) mette a disposizione il metapacchetto buil-essentials che ha tra le sue dipendenze tutti i tools base per la compilazione:

sudo apt-get install build-essentials

Un altro pacchetto la cui presenza è consigliata, prima della compilazione, è checkinstall:

sudo apt-get install checkinstall

Ottenere i sorgenti

Generalmente i sorgenti di un pacchetto sono reperibili sulla home page del progetto o dello sviluppatore, in un qualche tipo di archivio. I formati più comuni sono:

• tar.gz (archiviato con tar e compresso con gzip)
• tar.bz2 (archiviato con tar e compresso con bzip2)
• zip (archiviato e compresso con gzip)

Per estrarre un archivio tar.gz o tar.bz2, ad es, è sufficiente lanciare i comandi (rispettivamente):

tar xzvf nomeprogetto-versione.tar.gz
tar xjvf nomeprogetto-versione.tar.bz2

dove x sta per extract, z per uncompress gz (j per uncompress bz2), v per verbose e f per file (l’archivio da decomprimere)

In alcuni casi, occorre prelevare i sorgenti direttamente dal repository utilizzato dagli sviluppatori per la revisione del codice. I CSM maggiormente utilizzati al momento sono svn, mercurial e git

Anatomia di un pacchetto di sorgenti

Una volta decompresso l’archivio dei sorgenti di un pacchetto, nella directory creata si dovrebbero trovare i seguenti file (secondo le raccomandazione GNU per la distribuzione di sorgenti):

• INSTALL: istruzioni per la comèpilazione e l’installazione
• COPYING: le informazioni sulla licenza
• NEWS: novità e bugfix della versione corrente del pacchetto
• README: descrizione del pacchetto
• AUTHORS: informazioni sul progetto e sul gruppo di sviluppatori
• ChangeLog: cambiamenti nelle varie versioni del pacchetto

• configure: script di autoconfigurazione per la compilazione

• src: directory dei sorgenti (opzionale)
• doc: directori dei sorgenti della documentazione (opzionale)
• tests: directory con programmi di test per validadre la compilazione/installazione (opzionale)

Configurazione e compilazione

Grazie agli autotools del progetto GNU, gli step per configurare e compilare un pacchetto dai suoi sorgenti è un processo per lo più semplice e standard. In quasi tutti i casi i comandi da lanciare, dopo aver decompresso l’archivio ed essersi spostati nella directory creata sono 3:

./configure
make
make install

Il primo comando lancia uno script di autoconfigurazione, in cui viene effettuato un probing del sistema, per verificare se tutte le dipendenze (ad es. la presenza di alcune librerie) sono soddisfatte. Al termine di questo processo (che può durare anche alcuni minuti), viene generato un file di configurazione per il comando make (Makefile)

Il secondo comando effettua la compilazione vera e propria (a seconda della dimensione del progetto e della potenza della macchina, questa fase può durare anche alcune ore)

Il terzo e ultimo comando serve ad installare i binari ottenuti in fase di compilazione nelle directory di sistema

Note sulla configurazione (1/2)

Il processo di autoconfiguarzione, che come si è visto viene effettuato dallo script configure, è in genere la fase più delicata nel processo di installazione da sorgenti.

Configure in generale offre una serie di opzioni per modificarne il comportamento; per ottenere la lista delle stesse è sufficiente lanciare lo script con lo switch —help:

./configure --help

Per portare a termine con successo il task di configurazione, è necessario installare sul sistema tutte le dipendenze richieste dal software che si intende compilare. La determinazione delle stesse è un compito che richiede una certa esperienza (anche se esistono dei tool che vengono in aiiuto dell’utente). In generale comunque, è sufficiente prestare attenzione ai messaggi di configure.

Note sulla configurazione (2/2)

In distribuzioni Debian based, l’installazione delle dipendenze è abbastanza semplice: è sufficiente installare, dopo averne determinato il nome con apt-cache, le librerie richieste e i relativi pacchetti di sviluppo (si differenziano dal resto dei pacchetti perché terminano con il prefisso -dev e contengono gli header file necessari alla compilazione)

Es.:

#Ricerca di librerie relative ad Alsa
apt-cache search alsa

#Installa il pacchetto di sviluppo e, come dipendenza, la libreria
apt-get install libasound2-dev

Make

Make è un tool per il controllo automatico delle dipendenze nella compilazione (building) di sorgenti. La configurazione di make si effettua attraverso un file di testo (makefile) in cui vengono elencati con una sintassi abbastanza semplice tutti i comandi necessari, e l’ordine con cui gli stessi devono essere eseguiti.

Make offre le seguenti caratteristiche:

• permette la compilazione di un progetto senza conoscerne l’architettura (queste informazioni vengono scritte dallo sviluppatore nel makefile)
• determina automaticamente quali binari necessitano di una ricompilazione, sulla base dei cambiamenti ai file
• è uno strumento di uso generale (non limitato ad un singolo linguaggio di programmazione)

Un makefile è basato su una serie di regole, richiamabili attraverso un target. Ciascuna regola specifica le eventuali altre regole da cui dipende, e i comandi che devono essere eseguiti.

Makefile standard target

La toolchain GNU aggiunge automaticamente al makefile dei pacchetti sviluppati con gli autotools alcuni target standard:

• make all: target di default (è sufficiente lanciare make), compila binari, librerie e documentazione (ove presenti)

• make install: installa il pacchetto copiando i binari nelle directory di sistema (default: /usr/local/[lib|bin|doc…])

• make uninstall: rimuove i binari dalle directory di sistema

• make clean: cancella dal tree dei sorgenti i binari generati con make all

• make distclean: cancella dal tree dei sorgenti i binari generati con make all e i Makefile generati dallo script configure

• make dist: rigenera l’archivio dei sorgenti nella forma pacchetto-versione.tar.gz

Installazione

L’installazione dei binari, dopo la fase di compilazione, può essere effettuata lanciando semplicemente il comando:

make install

Tuttavia questo approccio presenta il grosso svantaggio di non interfacciarsi con il sistema di pacchettizzazione della distribuzione, rendendo dunque la successiva disinstallazione abbastanza complicata. Per ovviare a questo inconveniente esiste il programma checkinstall.

Checkinstall utilizza il comando passatogli in argomento (generalmente make install) per generare un pacchetto binario a scelta tra i formati Debian, Redhat (rpm) o Slackware, e successivamente lo installa mediante i tool standard della distribuzione. Per installare da sorgenti mediante checkinstall si utilizza dunque il comando:

checkinstall make install

Quando manca configure…

Alle volte può succedere, soprattutto se si scaricano i pacchetti dal repository di sviluppo, che nel tree dei sorgenti NON sia presente uno script configure.

In questi casi, per prima cosa è necessario controllare nel tree dei sorgenti se sia presente uno script chiamato autoconf.sh, o template per gli autotools (Makefile.am e configure.ini).

Nel primo caso è sufficiente eseguire lo script (./autoconf.sh), nel secondo invece bisogna utilizzare il comando autoconf (autotools). In entrambi i casi il risultato sarà la creazione dello script di autoconfigurazione (configure)

È comunque consigliato, prima di procedere in questi passi, leggere il file INSTALL, che dovrebbe contenere informazioni più dettagliate sulle operazioni da compiere.

Compilazione del kernel

La compilazione del kernel è considerata ancora una sorta di arte oscura. In effetti per non incorrere in spiacevoli inconvenienti (difficoltà in fase di avvio, freeze successivi..) occorre conoscere almeno sommariamente l’architettura di un sistema basato su Linux ed il relativo processo di boot

In aggiunta, la configurazione del kernel si basa su tools ad-hoc diversi da quelli precedentemente visti. Ciò è dovuto essenzialmente a:

• dimensione del progetto e dell’albero dei sorgenti (complessivamente, più di un milione di linee di codice)
• dipendenze di compilazione tra driver (ad es. il supporto per una scheda wifi non può essere conpilato senza aver prima selezionato lo stack protocollare mac802.11)
• numero di opzioni estremamente elevato (si parla di driver per la maggior parte delle periferiche in commercio, alcune decine di filesystems, supporto a svariate architetture…)

Ottenere i sorgenti del kernel

La fonte ufficiale per reperire il kernel vanilla Linux (per vanilla si intende il kernel direttamente rilasciato da Linus Torvalds) è il sito ftp.kernel.org (ed i relativi mirror nazionali).

In rete possono essere rintracciate versioni modificate di Linux, o singole patch, che aggiungono funzionalità ancora sperimentali, o codice per il supporto a piattaforme hardware diverse da quelle supportate direttamente nel vanilla.

È anche possibile scaricare i sorgenti del kernel direttamente dai repository della distribuzione. In questo modo però, si ottiene una versione comprensiva di tutte le patch applicate dal distributore (ad es. Ubuntu aggiunge al vanilla patch per la gestione di hardware ancora sperimentale, configurazioni specifiche e filesystem non ancora entrati nel tree vanilla, come aufs)

Configurazione del kernel (1/2)

La configurazione del kernel consiste nella scelta dell’architettura, delle funzionalità e dei driver di periferiche (in gergo moduli) che si vorranno utilizzare.

Tutto il processo di building del kernel è pilotato dal programma make. Per accedere alla configurazione, è possibile lanciare uno dei seguenti comandi, che compila e lancia il rispettivo tool di configurazione:

• Configurazione testuale (scripts/kconfig/conf)

  make config
  

• Configurazione con menù ncurses (scripts/kconfig/mconf)

  make menuconfig
  

Configurazione del kernel (2/2)

• Configurazione attraverso un tool qt o gtk (scripts/kconfig/qconf o scripts/kconfig/gconf):

  make xconfig
  make gconfig
  

• Configurazione sulla base di una precedente versione (deve esistere un file .config e verranno poste solo le domande per le quali non sia presente una risposta)

  make oldconfig
  

Nota: nei kernel della famiglia 2.6 il backend di configurazione è stato unificato (libkconfig). Tutti i comandi precedenti dunque parsano i file Kconfig presenti nell’albero dei sorgenti per valutare dipendenze e scelte dell’utente

Compilazione e installazione standard

Il passo successivo alla configurazione è, naturalmente, la compilazione vera e propria. Questo processo può durare anche alcune ore, ed è pilotato da una serie di regole nel Makefile. In particolare:

• make: compila kernel (vmlinuz), moduli e costruisce l’immagine compressa (bzImage). Nei kernel della serie 2.4 questi task dovevano essere effettuati separatamente, rispettivamente con i comandi make, make modules e make bzimage, preceduti da un make depends per il controllo delle dipendenze.

• make install: installa il kernel o l’immagine compressa dello stesso (bzImage) nella directory di sistema /boot

• make modules_install: installa i moduli nella directory du sistema /lib/modules/`uname -r`

Compilazione e installazione in debian way

Le distribuzioni Debian based offrono un comodo tool (make-kpkg) per la compilazione e l’installazione del kernel Linux. Per installare questa utility lanciare il comando:

apt-get install kernel-package

Per l’installazione in debian-way, dopo le normali fasi di configurazione, sarà sufficiente lanciare il comando:

make-kpkg --append-to-version -nomepersonalizzato --revision=1 kernel_image

che creerà automaticamente un pacchetto del tipo: linux-image-versione-nomeprsonalizzato-i386_1.Custom_i386.deb, installabile con dpkg.

Postconfigurazione di un nuovo kernel

Una volta installato un nuovo kernel (sia nella maniera classica che in debian way), occorre eseguire due passi di post-configurazione:

• creazione del ramdisk initrd (necessario solo se i driver necessari al boot non sono stati compilati in modo statico)
• aggiornamento del boot loader.

In Debian queste operazioni sono effettuabili con due semplici comandi:

update-initramfs -k versione -c
update-grub