7.1.2 La compilazione

Essendo un programma che deve essere eseguito come programma di base (senza potersi avvalere dell’ausilio di altri programmi già in esecuzione) è necessario che il kernel sia un programma comprensibile al computer, ovvero in linguaggio macchina. Vista la complessità della scrittura di un programma come il kernel, risulterebbe ancora più complesso scriverlo direttamente in linguaggio macchina. Per questo, anche se parti più critiche sono scritte in assembly (un linguaggio di programmazione che molto si avvicina al linguaggio macchina), la maggior parte del kernel è scritto in un linguaggio di programmazione a più alto livello (ma non troppo): il C. Dunque l’immagine del kernel è il risultato di una compilazione dei suoi sorgenti.

Poiché il kernel deve offrire anche performance elevate, non sarebbe pensabile di utilizzare un programma interpretato, che per la presenza dell’interpretazione delle istruzioni avrebbe performance decisamente inferiori all’analogo compilato.

Poiché GNU/Linux è un sistema opensource, i sorgenti del kernel sono distribuiti insieme al sistema ed inoltre, poiché si tratta di free software è possibile modificare e ricompilare il kernel - sì, proprio così! - adattandolo al proprio hardware e personalizzandolo secondo le proprie specifiche esigenze.

Poiché questa operazione potrebbe compromettere il funzionamento dell’intero sistema (si ricordi che il kernel è il nucleo di base del sistema) si consiglia di farlo seguendo opportune indicazioni che comunque permetteranno di ripristinare facilmente la situazione precedente.

Per la compilazione del kernel è necessario avere installato sul sistema i tool per la compilazione, cioè i pacchetti necessari per compilare i sorgenti C (compilatore e librerie), nonché i file sorgenti del kernel.

La procedura di seguito descritta non modificherà né distruggerà il kernel già presente sul sistema, ma si limiterà a produrre un altro kernel. In un sistema GNU/Linux è possibile infatti avere più immagini del kernel sul filesystem e scegliere in fase di boot quale kernel avviare.

Reperimento dei file sorgenti del kernel.
I file sorgenti del kernel di GNU/Linux possono essere reperiti in vari modi. Bisogna fare molta attenzione a reperire i sorgenti del kernel opportuno, poiché, in genere, le varie distribuzioni di GNU/Linux modificano il kernel Linux ufficiale (il cosiddetto vanilla kernel) secondo le proprie esigenze. Ad esempio, i sorgenti del kernel di una distribuzione RedHat sono contenuti in pacchetti rpm presenti nella directory RedHat/RPMS sui CD della distribuzione, che viene generalmente montata come /mnt/cdrom/RedHat/RPMS, e possono quindi essere installati sul sistema con i seguenti comandi
```
     # cd /mnt/cdrom/RedHat/RPMS
     # rpm -i kernel-headers*.rpm
     # rpm -i kernel-source*.rpm
     # rpm -i dev86*.rpm
     # rpm -i bin86*.rpm
                                                                        
                                                                        
  
```
I file bin86*.rpm sono richiesti soltanto per i vecchi sistemi GNU/Linux.
Copia del file di configurazione
Se si vuole compilare un nuovo kernel con le stesse impostazioni di uno eventualmente già compilato in precedenza, si può copiare il file di configurazione.
```
  # cd /usr/src/linux
  # cp ../linux-old-tree/.config .
  
```
o alternativamente utilizzare il comando make oldconfig che risponderà a tutte le varie domande di make, con i valori contenuti nel file .config presente nella working directory.
Pulire l’ambiente di compilazione
```
  # cd /usr/src/linux
  # make clean
  # make mrproper
  
```
Mr Proper è un prodotto finlandese per pulizie, che probabilmente ha ispirato Linus Torvalds.
_______________________________________________________________
Comando: make
Path: /usr/bin/make
SINTASSI
$ make [option]
DESCRIZIONE
- option indica la modalità di funzionamento di make. Può assumere i seguenti valori
  - ? ?;
_____________________________________________________________________________________________________________________
[da completare ...]
Configurare i parametri di compilazione
La configurazione dei parametri di configurazione può essere effettuata sia da shell che dall’ambiente grafico.
Per avviare l’ambiente grafico si può utilizzare il comando
```
  # startx
  
```
Quindi, dopo aver aperto un terminale (dall’ambiente grafico), si possono digitare i seguenti comandi
```
  # cd /usr/src/linux
  # make xconfig
  
```
A questo punto verrà visualizzata una finestra per l’impostazione dei parametri di compilazione del kernel.
Alternativamente, da una shell non grafica, si possono configurare i parametri di compilazione con il comando
```
  # make menuconfig
  
```
A questo punto apparirà sullo schermo una sorta di finestra per l’impostazione dei parametri di compilazione del kernel.
Se tale comando non funziona, si deve utilizzare la sua versione più vecchia, con il comando
```
  # make config
  
```
che visualizzerà una serie di domande che servono per impostare i parametri di compilazione del kernel.
In generale è consigliabile, dove possibile (specialmente nel caso di configurazione dall’ambiente grafico), impostare la configurazione come quella precedente, cioè con i valori contenuti nel file /usr/src/linux/.config (dall’ambiente grafico premere il pulsante Load Configuration from File), per poi eventualmente modificare soltanto le impostazioni che interessano.
- • È di fondamentale importanza impostare il corretto tipo di CPU presente sul sistema per poter ottenere un’immagine del kerenl funzionante sul proprio sistema.
- • Abilitare il supporto SMP nel caso di un sistema con più di una CPU.
- • Filesystems - È consigliabile impostare Windows95 Vfat, MSDOS, NTFS come parte del kernel e non come moduli esterni.
- • Abilitare il supporto per i moduli (Loadable Kernel Modules support) in modo da far così gestire dinamicamente al kernel il caricamento/scaricamento dalla memoria dei driver necessari (on-the-fly). Per maggiori dettagli si consiglia di consultare le seguenti man page: lsmod(8), insmod(8), rmmod(8), depmod(8) e modprobe(8) (contenute nel pacchetto module-init-tools).
Alla fine dell’operazione di impostazione della configurazione scegliere il salvataggio dei dati, in modo tale che la configurazione venga scritta nel file /usr/src/linux/.config.
Dipendenze
```
  # make dep
  
```
Assegnare un nome all’immagine del kernel
È consigliabile assegnare un nome all’immaine del kernel da creare in modo tale che questa sia differente da altre eventualmente presenti sul sistema e non interferisca pertanto con le altre. Una buona idea è quella di identificare l’immagine del kernel con la sua versione. Per far questo è sufficiente modificare il contenuto del file /usr/src/linux/Makefile con un qualsiasi text editor (in questo caso è utilizzato vi)
```
     # cd /usr/src/linux
     # vi Makefile
     
```
e modificare la riga che contiene la direttiva EXTRAVERSION. Per esempio cambiare la riga
```
     EXTRAVERSION = -2.4.2XXXXXXXXX
     
```
con
```
  EXTRAVERSION = -2.4.15MyKernel.10Jan2003
  
```
Compilazione dei moduli
Questo passo è necessario soltanto se è stato abilitato il supporto per i moduli (Loadable Kernel Module support) al passo 3, altrimenti si incorrerà n un messaggio di errore analogo a “unresolved symbols” durante la fase di caricamento del kernel.
```
  # cd /usr/src/linux
  # make modules
  # make modules_install
  
```
Questi comandi compileranno i moduli e li copieranno nell’opportuna directory (/lib/modules/kernel_version.
Compilazione del kernel
Prima di procedere con la compilazione dei sorgenti si può visualizzare il contenuto del file /usr/src/linux/arch/i386/config.in che contiene delle informazioni sulla compilazione dei sorgenti del kernel. Quindi si procede con la compilazione
```
  # cd /usr/src/linux
  # nohup make bzImage &
  
```
Il comando nohup (man page nohup(1)) lancia in esecuzione un processo immune al segnale SIGHUP (generalmente la shell invia un segnale SIGHUP a tutti i processi da essa creati, quando questa termina).
_______________________________________________________________
Comando: hohup
Path: /usr/bin/nohup
SINTASSI
# nohup [option] [command] [args]
DESCRIZIONE
- option indica la modalità di funzionamento di nohup. Può assumere i seguenti valori
  - --help visualizza un aiuto sommario di nohup;
  - --version visualizza laversione di nohup;
- command è il comando che deve essere lanciato ed il cui relativo processo deve ignorare i segnali SIGHUP. Al relativo processo viene inoltre assegnata una priorità aumentata di un valore 5 e pertanto il sistema continuerà la sua esecuzione anche se l’utente si scollega (effettua un logout). Se il canale di output è un terminale (standard output), questo, assieme al canale di error, viene automaticamente rediretto nel file nohup.out o, nel caso in cui non sia possibile, nel file ~/nohup.out;
- args sono gli eventuali argomenti da passare al comando command;
____________________
Per controllare il progredire dell’ultimo comando impartito (in esecuzione in background per la presenza di ‘&’), si può utilizzare il seguente comando
```
       # tail -f nohup.out
     
```
All fine di queste operazioni l’immagine del kernel sarà contenuta nel file /usr/src/linux/arch/i386/boot/bzImage
Copia dell’immagine del kernel in /boot
Il file contenente l’immagine del kernel deve essere copiato nella dierctory /boot altrimenti non potrà essere caricato durante la fase di boot del sistema. Questo può essere fatto con il comando
```
       # cp /usr/src/linux/arch/i386/boot/bzImage /boot/bzImage.myker.26mar2001
     
```
Per i kernel più recenti (versione 2.4.0 o superiore) possono essere creati anche i file /boot/initrd* (v. man page mkinitrd(8)) ed inserite le opportune direttive (initrd) nel file di configurazione del boot loader (per il caricamento dei RAM disk iniziali)³.
Configurazione del boot loader
[da completare ...]
Reboot
Riavviare la macchina con il comando
```
  # shutdown -r now
  
```
Alla presentazione dell’interfaccia del boot loader selezionare l’avvio del nuovo kernel. se tutto funziona correttamente il lavoro è finito, altrimenti si può riavviare nuovamente il sistema e far avviare al boot loader il kernel precedente (si ricordi che il kernel precedente è rimasto intatto), in modo da poter utilizzare il sistema ed eventualmente rivedere i passi precedentemente effettuati per “aggiustare” l’immagine del nuovo kernel.
Creare un floppy di avvio
Se il nuovo kernel funziona, si può creare un floppy per l’avvio del sistema col nuovo kernel.
```
  # cd /usr/src/linux
  # make bzdisk
  
```
v. anche mkbootdisk(?).
Pulire l’ambiente di compilazione
Una volta completato il tutto, si può ripulire l’ambiente di compilazione liberando spazio sul filesystem.
```
  # cd /usr/src/linux
  # make clean
  
```

[da completare ...]

[Avanti] [Indietro] [Su] [Indice]