------------------------------------------------------------------------------
(Ri)compilazione del kernel HOW-TO
------------------------------------------------------------------------------
By: WhiteR4bbit (whiter4bbit[at]linuxmail[dot]org)	linuxhowtos.altervista.org
Licenza: FDL
Ultimo aggiornamento: Aprile 2004
Testing: Debian sid (2.4.22; 2.6.1)
------------------------------------------------------------------------------
Fonti e link utili:
http://www.kernel.org
http://www.digitalhermit.com/~kwan/kernel.html
http://kerneltrap.org/node/view/799
http://newbiedoc.sourceforge.net/system/kernel-pkg.html
http://appunti.linux.it/a248.html#almltitle526
------------------------------------------------------------------------------
SOMMARIO:
1) Introduzione e concetti di base
2) Kernel 2.4
3) Kernel 2.6
4) Il kernel-package di debian
------------------------------------------------------------------------------

1) Introduzione e concetti di base

E' importante avere chiari alcuni concetti, su cui è facile confondersi, per non 
perdersi nelle sottigliezze di quello che riguarda il kernel Linux. Innanzitutto cosa 
è un kernel: trattasi del nucleo del sistema operativo, ossia quella parte che si occupa
di interagire con le periferiche e di gestire i processi; Linux in sè è esattamente un
kernel, e nulla più, le varie distribuzioni non fanno altro che costruirci qualcosa attorno,
aggiungendo software o vari tool di configurazione... quindi è tecnicamente errato dire,
ad esempio, "Mandrake è Linux", dato che Linux è SOLO il kernel del sistema operativo: 
Mandrake, e così ogni altra distro, è un sistema operativo basato su kernel Linux.
Quindi, quando voi scaricate i sorgenti di un kernel dal sito kernel.org, scaricate Linux;
ho detto sorgenti, esatto, come certamente saprete Linux è libero e aperto, quindi ovviamente
il codice sorgente viene distribuito liberamente e volendo lo potreste anche modificare.
Fatta questa premessa, è ora chiaro che il kernel può essere visto come qualcosa di distinto
dal resto del sistema, e quindi può essere cambiato o installato, e ne potete tenere diverse
versioni su un unico sistema. Il kernel Linux viene rilasciato in nuove versioni con una 
certa periodicità, suddivise in famiglie e in due rami (stabile e instabile): da poco si è
passati dalla famiglia 2.4 alla famiglia 2.6, e stanno ora iniziando ad uscire le prime
distribuzioni che includono un kernel 2.6; ogni famiglia ha poi diverse release, che apportano
ulteriori piccole modifiche e correggono (o creano :P) eventuali bug... si parlerà quindi così
di release 2.4.24 piuttosto che 2.6.3 e così via. Vi starete senz'altro chiedendo perchè si è
passati dalla 2.4 alla 2.6... e la 2.5? le famiglie con secondo numero dispari fanno parte del
cosìddetto ramo di sviluppo, ossia i vari kernel 2.3.x, 2.5.x eccetera vengono rilasciati senza
particolari garanzie di stabilità, e usati per provare nuove soluzioni.
Se siete curiosi dopo aver letto queste righe di vedere quale kernel avete installato nella
vostra distro, potete semplicemente dare il comando
$ uname -r

e a video apparirà la vostra versione di Linux. Eventuali suffissi "strani" indicano con 
ogni probabilità che il kernel in questione è stato patchato: diverse distribuzioni infatti
applicano delle patch a Linux, personalizzandolo a modo loro, e questo a volte può creare 
problemi di incompatibilità con i sorgenti "duri e puri" scaricabili da kernel.org, ma 
nessun problema, queste distribuzioni rilasciano dei pacchetti propri con i kernel già patchati
e potrete installare quelli. Ad esempio Mandrake, abituata ai suoi "-x.xxmdk" potrebbe non
digerire un kernel nudo e crudo, ma installando l'rpm kernel-source-Y.Y.YY-x.xxmdk" tutto 
dovrebbe funzionare egregiamente.
Introduciamo ora il concetto di (ri)compilazione di un kernel Linux: cosa significa? Niente
di particolarmente ostico, niente per cui sia necessario essere degli esperti informatici, 
niente che richieda nozioni di programmazione. In pratica avrete accesso ad un menu che vi 
chiederà quali caratteristiche attivare, quali disattivare, e quali rendere delle parti
facoltative da caricare a piacimento (i cosiddetti moduli). Queste caratteristiche sono,
ad esempio, il supporto per un particolare tipo di filesystem, o l'essere avvisati ad ogni
errore che avviene nella cpu. Si parla di compilazione quando si sta installando un kernel
nuovo, e di ricompilazione quando si stanno modificando le opzioni di quello già installato.
Dopo aver modificato queste impostazioni, le modifiche sono salvate su un file di configurazione
in base al quale il codice del kernel verrà (ri)compilato (il tutto con un paio di semplici
comandi, niente di difficile nemmeno qui).
E' abbastanza chiara quindi la risposta alla domanda che vi sarà sorta spontanea se siete 
nuovi a questo tipo di operazioni: perchè dovrei ricompilare il kernel, o peggio metterne uno
nuovo? Il motivo principale è che vorreste attivare il supporto per qualche periferica non 
inclusa di default, oppure che nella versione del kernel attualmente in uso non è ancora 
supportata. A dire il vero le configurazioni di default sono molto "di manica larga" ed è più
probabile trovare il supporto a decine di cose che non vi servono, piuttosto che trovare un'utile
opzione disattivata; qui entra in gioco il secondo motivo per cui dovreste voler (ri)compilare 
un kernel, ossia personalizzare Linux rendendolo adatto alla vostra macchina, alleggerendolo
del carico inutile e rendendolo così più snello, veloce ed elegante. 
Effettivamente le caratteristiche da attivare e disattivare sono moltissime, e sarebbe 
impensabile tra l'altro includere qui una spiegazione ad ognuna di esse: per fortuna esiste un 
help che vi spiega a cosa serve ogni opzione mentre decidete se includerla o meno nel nucleo.
Facciamo un esempio pratico, per chiarire ulteriormente cosa significa (ri)compilarsi un kernel:
avete deciso di provare il nuovo 2.6, attirati dalle feature che promettono maggiore velocità in
ambito desktop, e già che ci siete cercate di personalizzarlo prima di compilarlo e installarlo,
a seconda dell'hardware presente nella vostra macchina. Avete appena acquistato una scheda audio
e siete sicuri che non la cambierete per un bel po' di tempo, così entrate nella sezione "device
drivers" e cercate l'opzione per la vostra scheda, la attivate built-in nel kernel e poi
disattivate il supporto ad altri modelli di schede audio, che non possedete; avete un dual boot
con Windows98, quindi siete sicuri che non vi importi nulla di leggere partizioni in NTFS, dato
che non ne avete: entrate nella sezione "filesystems" e disattivate il supporto a NTFS. Avete 
inoltre una fotocamera digitale che usate ogni tanto, come unica periferica USB di massa... entrate
allora nella sezione "USB support" tra i device drivers, e decidete di attivare il supporto a
questo tipo di dispostivi come modulo, anzichè caricarlo built-in nel kernel, e in questo modo
vi basterà caricare il modulo appropriato quando vorrete usare la fotocamera digitale, mentre 
per il resto del tempo quest'opzione resterà disattivata evitando di appesantire il kernel.

Sperando che quanto scritto fin'ora risulti chiaro, passiamo a vedere più da vicino cosa
significa andare a toccare un kernel, e come è fisicamente disposto quest'ultimo nel nostro
filesystem. Avrete in ogni caso, ovviamente, bisogno dei sorgenti del kernel installati.
Essi si trovano nella directory /usr/src/linux, che è in realtà un collegamento alla vera
directory (personale per ogni versione del kernel) posta sempre in /usr/src; ricordate comunque
che il kernel in uso deve avere i sorgenti in /usr/src/linux.
E sarà proprio lì dentro che andrete a dare buona parte dei comandi atti a (ri)compilare il
vostro beneamato nucleo, inoltre è lì dentro che troverete la documentazione ufficiale e il 
file di configurazione del kernel, un semplicissimo file di testo nascosto che vi indica quali
impostazioni sono attive e quali no, presente come /usr/src/linux/.config (a dire il vero ne è
presente anche una copia in /boot).
Il kernel in sè, una volta compilato, avrà nome "vmlinuz-" seguito dai numeri caratteristici 
della release, e un po' come per le directory di prima sarà comodo creare un link simbolico
chiamato semplicemente "vmlinuz" che punti al kernel in uso. Il file del kernel, come
potrete appurare, peserà solamente 2M se non meno. Generalmente i kernel vengono posti nella
directory /boot, oppure direttamente nella radice, così avrete ad esempio:
/boot/vmlinuz-2.6.1-26feb04
/vmlinuz -> boot/vmlinuz-2.4.24

Come fate a dire al sistema di partire con un particolare kernel piuttosto che con un altro?
Vi basta modificare le impostazioni del bootloader indicandogli la posizione dell'immagine che
volete far partire, ad esempio se usate LiLo potrete avere un lilo.conf contenente queste righe:
image=/boot/vmlinuz-2.6.1
	[opzioni varie]
image=/boot/vmlinuz-2.4.22
	[opzioni varie]
	
in questo modo potrete selezionare quale dei due kernel far partire ad ogni avvio della
macchina.
Ovviamente sta a voi scegliere se modificare sempre la configurazione del bootloader o se 
modificare invece il link /vmlinuz e lasciare poi ad esempio un lilo.conf immutato:
image=/vmlinuz
	[opzioni varie]
	
Bene, abbiamo visto cosa è il kernel-source (il pacchetto dei sorgenti del kernel che dovrete
compilare, e peserà all'incirca 30M), e cosa è la kernel-image (l'immagine vera e propria del
vostro kernel, denominata vmlinuz-X.X.XX e pesante all'incirca 2M), tuttavia potreste incappare
in altre definizioni come ad esempio i kernel-headers o un certo file System.map: i primi sono
semplicemente i file di intestazione del kernel (se conoscete C/C++ sapete di cosa sto parlando)
che possono essere richiesti da alcuni programmi per essere installati correttamente... 
ovviamente se avete già i sorgenti del kernel completi installati sulla vostra macchina, non
avrete bisogno dei kernel-headers, essendo essi una parte del codice sorgente di Linux. Il file
System.map invece potete considerarlo una mappatura delle condizioni del vostro kernel in un
unico file di testo, le cui informazioni possono essere utili in fase di debugging. 
I kernel-headers saranno posizionati in /usr/src, mentre il System.map sarà nella stessa 
directory dell'immagine del kernel (quindi solitamente /boot) anch'esso contraddistinto, come 
vmlinuz, dai suffissi caratteristici della versione del kernel (e.g. /boot/System.map-2.6.1).
Un altro file di cui potreste leggere è initrd.img, utilizzato da alcune distribuzioni per 
montare un root filesystem temporaneo in fase di boot, prima che venga montato quello vero.

Cosa dovrete fare quindi per ricompilare o compilare un kernel Linux? nel caso doveste solo
ricompilare il vostro, dovrete installarne i sorgenti (se non li avete in /usr/src), copiare
il file di configurazione da /boot/config-X.X.XX a /usr/src/linux/.config (in modo da partire
dalla configurazione attuale senza fare tutto da capo) dopo avere ovviamente creato il link
simbolico "linux", entrare nella directory dei sorgenti, configurare il kernel, ricompilarlo e
reinstallarlo. Se dovete invece compilarne uno nuovo, dovrete prima scaricarne i sorgenti, 
scompattarli (o installarne il pacchetto a seconda della distribuzione che usate), creare il 
link simbolico "linux" e copiarci il file di configurazione del vecchio kernel se questo è 
della stessa famiglia di quello nuovo, entrare nella directory dei sorgenti, configurare il
kernel, compilarlo, installarlo e indicarne la posizione al bootloader.
Alcune distribuzioni come Mandrake dispongono già di pacchetti appositi contenenti i sorgenti
del kernel (kernel-source-) e anche di pacchetti che installano direttamente un'immagine di
un kernel (kernel-image- o semplicemente kernel-): in quest'ultimo caso non potrete configurare
a mano voi il tutto, ma vi può essere comodo se volete solo provare un kernel nuovo (con le
impostazioni di default).

In ultimo, è bene fare un excursus teorico sulla definizione tecnica del kernel Linux: Linux è
un kernel monolitico modulare. Spesso troverete confusione (anche sulla documentazione più
rinomata!) su questo punto, potreste leggere che Linux è un kernel modulare e non monolitico.
In realtà la distinzione principale viene fatta tra microkernel e kernel monolitico: il primo è
un kernel che si occupa solo delle operazioni basilari, lasciando a parti esterne (dette moduli)
che girano in user space (cioè in uno spazio di memoria diverso, e più sicuro) le altre 
mansioni. Un kernel monolitico invece è un unico kernel che gira sempre nello stesso spazio di
indirizzamento (kernel space). Linux è un kernel monolitico in quando anche se create e
utilizzate i suoi moduli, essi al momento del caricamento saranno parte del kernel, nel suo
stesso spazio di memoria (kernel space, appunto).
Può capitare comunque di parlare di configurazione monolitica o modulare del kernel Linux, 
intendendo il supporto o meno per i moduli in fase di (ri)compilazione, ma ricordate che anche
se attivate tutte le voci come modulo il vostro Linux resterà sempre un kernel monolitico, anche
se sarà pure modulare!




2) Kernel 2.4

Queste sezione spiega come (ri)compilare un kernel della famiglia 2.4; avrete innanzitutto bisogno
dei sorgenti installati, quelli del kernel in uso se dovete ricompilarlo, e quelli del kernel
nuovo se volete metterne appunto una nuova versione. Solitamente ogni distribuzione ha nei propri
cd o tra i pacchetti dei propri repository almeno il kernel-source in uso (ricordo che per 
controllare qual è il kernel in uso si può utilizzare il comando "uname -r"). Se utilizzate 
distribuzioni che non usano patchare pesantemente il kernel (e.g. Slackware e debian) potete anche
scaricarvi l'archivio ufficiale dal sito www.kernel.org
Vi servirà inoltre il pacchetto modutils per poter gestire i moduli (a meno che non vogliate 
compilarvi un kernel strettamente monolitico) e, a seconda che vogliate utilizzare menuconfig o
xconfig, le librerie ncurses o tk.
Prenderò ad esempio una situazione, per altro abbastanza diffusa, in cui abbiate installato debian
e vi ritroviate un kernel 2.4.18-bf2.4 che non vi soddisfa, e decidete così di rimpiazzarlo con un 
2.4.22 più aggiornato. La prima cosa da fare dopo aver installato i sorgenti è assicurarsi che 
essi siano in /usr/src/linux: create quindi questo link simbolico alla loro directory reale che,
se avete scaricato il pacchetto da kernel.org e lo avete scompattato in /usr/src, sarà linux-2.4.22
# ln -s /usr/src/linux-2.4.22 /usr/src/linux

Passate poi a copiarvi il file di configurazione
# cp /boot/config-2.4.18-bf2.4 /usr/src/linux/.config

Bene, avete ora i sorgenti del kernel che volete compilare al loro posto, accanto al relativo file
di configurazione: non vi resta che riconfigurarlo, dunque. Per farlo avete a disposizione tre 
diverse interfacce: config vi porrà delle domande in sequenza su console, cui dovrete rispondere
ogni volta, vivamente sconsigliato visto che l'ordine di grandezza si aggira sulle centinaia di 
opzioni; menuconfig invece vi offre un menu molto comodo e pulito, sempre da console; xconfig vi
offre lo stesso menu, però in modalità grafica (dovete avere XFree86 funzionante ovviamente per 
poterla utilizzare). Diciamo che menuconfig è una scelta molto valida, comoda e standard, adatta
a tutte le situazioni... in ogni caso il nome dell'interfaccia scelta dev'essere passata come 
parametro al make, quindi per iniziare a smanettare tra le opzioni date ad esempio il comando
# make menuconfig

all'interno della directory /usr/src/linux
Se volete semplicemente installare il nuovo kernel e non vi interessa attivare/disattivare qualche
opzione, potete anche saltare la configurazione, ma almeno un'occhiata vale la pena darla (ad
esempio potete selezionare il vostro tipo di processore all'interno di "Processor type and 
features", semplice, banale, ma può già velocizzare il sistema di qualche millisecondo). Quando
avete terminato di fare le vostre scelte, uscite scegliendo ovviamente di salvare la configurazione
e procedete ai passi successivi. 
E' il momento di fare un po' di pulizia prima di compilare:
# make dep
# make clean

sono i due comandi da dare in sequenza sempre dalla directory /usr/src/linux
Passate quindi alla compilazione vera e propria con
# make bzImage

Il tempo impiegato sarà di circa 5 minuti su un processore a 2Ghz, il nome del comando è dato dal
fatto che in alcune versioni di Linux l'immagine del kernel si chiama proprio bzImage e non vmlinuz.
Una volta creata questa immagine, spostatela in /boot con
# mv /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.4.22

L'ultima cosa da fare è dire al bootloader dove andare a prendere l'immagine del kernel.
Procediamo con ordine: ora dovete avere tutte le immagini dei vostri kernel in /boot, assieme ai
relativi System.map e file di config. Nella root directory (/) potrebbe esserci un link simbolico
chiamato vmlinuz che punta al kernel attuale. In /etc/lilo.conf avrete invece almeno una sezione
che indichi "image=PERCORSO DEL KERNEL".
Bene, se stavate solo ricompilando, assicuratevi che il percorso passato a LiLo corrisponda con 
l'immagine appena creata, mentre se stavate installando un nuovo kernel aggiungete una sezione,
identica a quella che già era presente, passandogli però questa nuova kernel-image e modificando
la label. Ad esempio:
image=/boot/vmlinuz-2.4.18bf2.4
        label=Debian2.4.18
	[altre opzioni]
image=/boot/vmlinuz-2.4.22
        label=Debian2.4.22
	[altre opzioni]
	
Questa potrebbe essere parte di un lilo.conf predisposto a far partire due differenti kernel.
Ricordatevi di lanciare LiLo dopo aver modificato il suo file di configurazione:
# lilo

Se non vi dà errori siete a cavallo, altrimenti controllate che i path indicatigli siano corretti.
L'ultimissima cosa da fare, se avete deciso di fare uso dei moduli, è proprio compilare e installare
questi ultimi, il che si fa con due semplici comandi:
# make modules
# make modules_install

Il tempo richiesto sarà all'incirca il medesimo impiegato dal make bzImage.
Finito: non vi resta che riavviare, selezionare il nuovo kernel, e pregare che sia tutto a posto.




3) Kernel 2.6

Negli ultimi mesi del 2003 si è conclusa la fase di test del nuovo sfavillante kernel Linux, 
rilasciando la versione stabile del 2.6.0; i miglioramenti rispetto alla famiglia 2.4 sono 
notevoli: il kernel è fully preemptive anche in kernel-space, lo scheduler dei processi e quello
delle periferiche di input/output sono stati migliorati e velocizzati, così come la gestione dei
thread, è stato aggiunto un nuovo filesystem virtuale che si occuperà di gestire i device (sysfs,
rilasciando a proc il solo compito di occuparsi dei processi), si ha infine il supporto per il
nuovo reiser4 e ALSA e lm_sensors sono integrati direttamente nel kernel.
Per i meno "addetti ai lavori", tutto questo significa che il sistema risponderà più velocemente,
che non si avranno rallentamenti mentre si copiano dei file di grosse dimensioni su hard disk, che
avrete dei driver audio più performanti senza bisogno di installarli separatamente e che in generale
tutto sarà più ordinato e veloce. Ovviamente ho tralasciato alcune feature e molti particolari, ma
credo che quanto detto in queste poche righe possa già essere uno stimolo a provare questo nuovo 2.6,
se ancora non lo avete fatto.
Passiamo dunque ai requisiti di pre-compilazione: vale innanzitutto quanto detto per il 2.4, ossia
avete bisogno dei sorgenti del kernel (di quello in uso se dovete ricompilare, di quello nuovo se lo
volete cambiare) che potete trovare tra i pacchetti della vostra distro o sul sito kernel.org; in
quest'ultimo caso dovrete scompattare l'archivio in /usr/src e creare un link simbolico "linux" alla
directory che si creerà (come più volte detto in precedenza, la directory dei sorgenti dev'essere
raggiungibile dal path /usr/src/linux). Il pacchetto che gestisce i moduli è cambiato, niente più
le vecchie modutils bensì i nuovi module-init-tools; sono cambiate anche le interfacce grafiche per
la configurazione del kernel, al posto del vecchio xconfig in tk avrete un nuovo omonimo xconfig in
qt (le librerie di KDE) e un nuovissimo gconfig in gtk (le librerie di Gnome), mentre per menuconfig
rimangono le fidate ncurses. Una volta installato quanto vi serve, dunque, procediamo...
L'esempio che farò adesso è, se vogliamo, un seguito di quello fatto per il kernel 2.4: mettiamo che
volete affiancare al vostro 2.4.22 un kernel 2.6.1, per curiosità o per necessità.
Dopo aver creato il solito link simbolico, sostituendolo a quello vecchio
# rm -f /usr/src/linux
# ln -s /usr/src/linux-2.6.1 /usr/src/linux

dovrete procedere alla configurazione. Non è possibile in questo caso copiare il vecchio config, dato
che state passando da una famiglia all'altra (2.4 -> 2.6), perciò a meno che la vostra situazione sia
differente (ad esempio state passando da un 2.6.0 a un 2.6.1, o state semplicemente ricompilando il
vostro kernel) dovrete fare tutto dall'inizio. Ricordo comunque che il file suddetto si trova 
in /boot, nel caso ne abbiate necessità. 
Configurare un kernel da zero può essere molto impegnativo a seconda delle vostre conoscenze, ed è 
probabile che dovrete ricompilare più volte prima di vedere tutto funzionante alla perfezione, ma non 
sarà un grosso problema, in fondo ci sono passati tutti... Scrivo comunque qualche consiglio 
particolarmente utile nello specifico caso di un passaggio da 2.4 a 2.6; l'agpgart, ossia la funzione
che si occupa di controllare la porta AGP, cui è collegata ad esempio la vostra scheda video, è ora
suddiviso in due parti: una è il solito agpgart e l'altra è relativa al chipset della vostra scheda
madre; scegliete quindi entrambi e includeteli nel kernel se volete utilizzare la porta AGP. 
I driver audio sono cambiati (OSS -> ALSA) quindi se non avete mai usato ALSA prima d'ora dovrete 
installarvi dei pacchetti specifici: alsa-libs e alsa-utils che trovate tra i cd della vostra distro
oppure sul sito ufficiale
* www.alsa-project.org

assicuratevi inoltre di attivare oss-emul, oss-pcm e oss-mixer.

Bene, passiamo alla pratica e vediamo come configurare questo beneamato kernel 2.6: come accennato
in precedenza qualcosa è cambiato tra le interfacce di configurazione, e oltre al solito obsoleto
config (che vi porrà delle domande in sequenza su console, cui dovrete rispondere ad una ad una), 
avrete ancora il menuconfig, ben due interfacce grafiche (xconfig e gconfig) e una nuova oldconfig
che si rivela utile nel caso passiate ad esempio da un kernel 2.6.1 a un kernel 2.6.2 e volete 
rispondere solo alle domande relative alle nuove feature. Il menuconfig resta a mio parere la scelta
migliore, ricordo che vi presenta un comodo e chiaro menu a console, utilizzabile anche se non avete 
XFree86. Qualunque sia l'interfaccia che scegliate, passatela come parametro al make, ad esempio
# make menuconfig

dalla directory /usr/src/linux per iniziare a configurare il kernel.
Fatte le vostre scelte, è ora di compilare, e qui il metodo è cambiato radicalmente rispetto al 2.4
con l'eliminazione di make dep e company, e la presenza di un comodissimo make all che "fa tutto lui".
Con make help potrete vedere le varie opzioni, ma dando semplicemente
# make all

andate sul sicuro, e il sistema inizierà a compilare. Ricordo che tutti questi comandi vanno dati
dalla directory dei sorgenti del kernel... Ultima fase, l'installazione dei moduli:
# make modules_install

Entrambe queste operazioni dovrebbero prendervi circa 5 minuti (a testa, con un processore a 2Ghz).
L'ultima cosa da fare per avere il kernel perfettamente installato e' sistemare il bootloader,
indicandogli dove andare a prendere l'immagine del kernel. Vale quanto detto per il 2.4:
Procediamo con ordine: ora dovete avere tutte le immagini dei vostri kernel in /boot, assieme ai
relativi System.map e file di config. Nella root directory (/) potrebbe esserci un link simbolico
chiamato vmlinuz che punta al kernel attuale. In /etc/lilo.conf avrete invece almeno una sezione
che indichi "image=PERCORSO DEL KERNEL".
Bene, se stavate solo ricompilando, assicuratevi che il percorso passato a LiLo corrisponda con 
l'immagine appena creata, mentre se stavate installando un nuovo kernel aggiungete una sezione,
identica a quella che già era presente, passandogli però questa nuova kernel-image e modificando
la label. Ad esempio:
image=/boot/vmlinuz-2.4.22
        label=Debian2.4.22
	[altre opzioni]
image=/boot/vmlinuz-2.6.1
        label=Debian2.6.1
	[altre opzioni]
		
Questa potrebbe essere parte di un lilo.conf predisposto a far partire due differenti kernel.
Ricordatevi di lanciare LiLo dopo aver modificato il suo file di configurazione:
# lilo

Se non vi dà errori siete a cavallo, altrimenti controllate che i path indicatigli siano corretti.

Sistemiamo ora le cose per il nuovo filesystem virtuale (sysfs) creandogli una directory che farà 
da punto di mount:
# mkdir /sys

e dedicandogli una sezione in /etc/fstab, che editerete da root aggiungendogli la riga
sys             /sys            sysfs   defaults        0       0

Siete a posto. Riavviate e incrociate le dita... La prima cosa che noterete se venite da un 2.4 sarà
probabilmente la velocità del puntatore del mouse aumentata considerevolmente, mentre se non avete
mai usato ALSA ecco un paio di comandi utili per permettere al vostro nuovo Linux di emettere suoni:
$ cat /proc/asound/cards

vi permetterà di controllare che ALSA abbia riconosciuto la vostra scheda, mentre con
$ alsamixer

Potete alzare i volumi (sono a zero di default): togliete il muto premendo M a Master e PCM e alzateli
al valore desiderato (usando le frecce), poi con alt+q uscite, e con
# alsactl store

Salvate le impostazioni.




4) Il kernel-package di debian

Se utilizzate una debian, avrete un tool pensato ad-hoc per semplificare la (ri)compilazione del
kernel, che funziona sia con i 2.4 sia con i 2.6 indistintamente. A dire il vero potreste utilizzare
anche il metodo classico descritto in precedenza, funzionerà, ma l'utilizzo del kernel-package
rende più facile e ordinato il tutto, inoltre è sempre meglio attenersi ai metodi propri di una 
distribuzione per evitare eventuali problemi di incompatibilità in seguito. 
Quindi, come sempre, vediamo prima i requisiti: vi servirà ovviamente il pacchetto kernel-package
stesso, oltre ai sorgenti del kernel che volete installare, alle modutils (se è un 2.4) o ai 
module-init-tools (se è un 2.6), e alle ncurses per utilizzare il menuconfig. Ovviamente gcc e libc
sono dati per scontati. Ad esempio se avete deciso di mettere un 2.6.4 potreste dare
# apt-get install kernel-package kernel-source-2.6.4 module-init-tools libncurses5-dev

Bene, ora spostatevi in /usr/src e scompattate i sorgenti, cambiando poi il link simbolico linux:
# cd /usr/src/
# tar -xjf kernel-source-2.6.4.tar.bz2
# rm -f linux
# ln -s kernel-source-2.6.4 linux

Spostatevi nella directory /usr/src/linux e passate a configurare il kernel: vale quanto detto in
precedenza, ossia potete copiarci il vecchio config (che trovate in /boot e che copiereste qui con
il nome ".config") solo se state trattando kernel della stessa famiglia, mentre se passate da un 2.4
a un 2.6 non fatelo; avrete diverse interfacce disponibili, ma la migliore nonchè valida per i kernel
di qualunque famiglia è menuconfig. Dunque
# cd /usr/src/linux
# cp /boot/config-2.6.0 ./.config
# make menuconfig

al posto di menuconfig potete usare oldconfig se state cambiando tra due release (entrambe 2.6.x)
particolarmente vicine tra loro, dovrete così solo rispondere alle domande relative i cambiamenti tra
l'una e l'altra. Potete anche usare prima oldconfig e poi menuconfig se dovete fare altre modifiche.
Fate le vostre scelte come sempre quindi, dopodichè uscite, salvate e preparatevi alla compilazione.
E' qui che entra in gioco il kernel-package: con due semplici comandi potrete fare un po' di pulizia
e successivamente compilare kernel e moduli; vi si creerà un normalissimo pacchetto deb che conterrà
il nuovo kernel da installare normalmente con dpkg.
Un paio di appunti sulle opzioni che è possibile passare in fase di compilazione: il nome del
pacchetto che creerete sarà così strutturato:
* kernel-image-(kernel-version)(--append-to-version)_(--revision)_(architecture).deb

(kernel-version) è ovviamente la release del kernel (in questo caso 2.6.4), (architecture) è 
l'architettura del vostro calcolatore (i386 nei normali PC), mentre le altre due sono due opzioni
che potrete passare al comando di compilazione: (--append-to-version) definisce un suffisso che
andrà a finire direttamente nel nome del kernel, potrete usarla ad esempio per differenziare due
kernel della stessa release ma compilati in due date differenti. Nel suo nome potrete usare i
caratteri '-', '.', '+', ma non '_' (underscore). Se non specificate un'append diverso durante una
ricompilazione, sovrascriverete l'attuale kernel (moduli compresi), quindi è consigliabile usare
sempre quest'opzione, anche per una questione di ordine. (--revision) invece è un ulteriore suffisso
che andrà a porsi nel nome del pacchetto deb creato ma non nel nome del kernel; modificare questo
parametro quindi non vi salverà da eventuali sovrascritture, non è che sia utilissimo a dire il vero,
il suo nome di default è "10.00.Custom".

Passiamo quindi all'azione dando i seguenti comandi (sempre dalla directory dei sorgenti):
# make-kpkg clean
# make-kpkg --append-to-version=-26mar04 kernel_image kernel_headers

In questo modo avrete creato due pacchetti deb, l'immagine del kernel e i suoi header (che possono
servire per qualche applicazione che li richieda espressamente): li troverete in /usr/src e avranno
nome
* kernel-image-2.6.4-26mar04_10.00.Custom_i386.deb
* kernel-headers-2.6.4-26mar04_10.00.Custom_i386.deb

rispettivamente. 
Per installarli procedete con dpkg:
# cd ..
# dpkg -i kernel-image-2.6.4-26mar04_10.00.Custom_i386.deb kernel-headers-2.6.4-26mar04_10.00.Custom_i386.deb

Al termine dell'installazione vi verranno poste tre domande: 
1) se volete creare un floppy di ripristino (bootdisk).
Potrebbe essere una buona idea rispondere sì, se non ne avete già uno; in ogni caso potete farlo
quando volete con mkboot.
2) se volete installare un bootblock usando l'/etc/lilo.conf attuale.
Rispondete di no, o tenterà di avviare il nuovo kernel mantenendo le impostazioni del vecchio, e non
partirà nulla...
3) se volete sostituire il lilo.conf attuale con uno nuovo predisposto per far partire il nuovo kernel.
Rispondete di no anche a questa, è meglio fare tutto manualmente, si è più sicuri di quel che si fa :P

L'unica cosa che vi resta da fare ora è proprio impostare il bootloader, come più volte descritto
nelle sezioni precedenti. Fatelo dunque, riavviate e controllate che sia tutto a posto.
Ora potete anche eliminare (o spostare altrove) i pacchetti deb creati, e volendo potete anche 
cancellare il link "linux" in /usr/src.