Creare un Kernel personalizzato
Molti nuovi utenti di Linux spesso si chiedono: "per quale motivo dovrei ricompilare un kernel personalizzato?" Con l'introduzione della modularizzazione del kernel di Linux la risposta migliore è: "se non sai per quale ragione hai bisogno di ricompilare il tuo kernel, allora probabilmente non c'è bisogno che tu lo faccia". Perciò se non desiderate ricompilare il kernel, potete saltare questa sezione consultando direttamente la la sezione Sendmail.
In passato vi veniva chiesto di ricompilare il kernel ogni volta che aggiungevate una nuova periferica o se volevate utilizzare altri tipi di filesystem. Il kernel era, in altre parole, statico. I miglioramenti nel kernel di Linux 2.0.x hanno consentito di modularizzarlo e quindi utilizzare driver di hardware che possono essere caricati senza dover eseguire una ricompilazione. Con le versioni precedenti del kernel vi erano dei problemi nell'utilizzo di più kernel ricompilati su un solo sistema per differenti utilizzi (ad esempio: un kernel SMP per macchine multiprocessore contro UP); problema risolto con l'attuale versione del kernel, permettendo un più facile utilizzo di un sistema con più kernel.
Per ricevere ulteriori informazioni sull'utilizzo dei moduli del kernel si veda la sezione Caricare i moduli del Kernel nel Capitolo 3. La maggior parte dei cambiamenti non sono visibili eccetto quando si ricompila il kernel per il vostro sistema.
Costruire un kernel modulare
Questo paragrafo ha l'obiettivo di fornirvi le istruzioni per usufruire delle potenzialità del kernel modulare. Se non volete sfruttare i vantaggi del kernel modulare, consultate la la sezione Ricompilare un kernel monolitico per maggiori chiarimenti sui differenti aspetti nella costruzione ed installazione di un kernel monolitico. Diamo per scontato che abbiate già installato i pacchetti kernel-headers e kernel-source e che tutti i comandi siano eseguiti dalla directory /usr/src/linux/.
È fondamentale accertarsi di avere un dischetto di emergenza funzionante in caso di eventuali errori. Se non ne avete creato uno in fase di installazione, utilizzate il comando mkbootdisk nel seguente modo: mkbootdisk --device /dev/fd0 2.2.x sostituendo 2.2.x con la versione del kernel installata sul vostro calcolatore. Una volta terminato provate il disco di emergenza per assicurarvi che funzioni.
È importante iniziare la ricompilazione del kernel con l'albero delle sottodirectory dei sorgenti il più "pulito" possibile. Pertanto, è consigliabile eseguire prima di tutto il comando make mrproper. Questo rimuoverà qualsiasi file di configurazione lasciato da eventuali precedenti ricompilazioni. Successivamente dovrete creare un file di configurazione che determinerà quali componenti includere nel vostro nuovo kernel. I metodi per configurare il kernel vengono elencati di seguito:
make config -- avvia un programma di testo interattivo. I componenti da includere nel kernel sono presentati sequenzialmente e vi verrà data la possibilità di rispondere con: Y (si), N (no), o M (modulo).
make menuconfig -- avvia un programma di configurazione tramite menu grafici. I componenti sono raggruppati e presentati in menu ordinati per categorie. Selezionate quelli desiderati nello stesso modo utilizzato durante il programma di installazione di Red Hat Linux. Selezionate gli elementi corrispondenti digitando una Y (si), una N (no), o una M (modulo).
make xconfig -- avvia un programma basato sul sistema X Window. I componenti sono elencati in differenti livelli di menu, e vengono selezionati usando il mouse. Anche qui le scelte possibili, sono Y (si), N (no), o M (modulo).
make oldconfig -- Questo è uno script non interattivo che creerà i Makefile necessari con la configurazione di default. Se state usando un kernel modificato, Red Hat Linux effettuerà un set up della configurazione di default. Ciò sarà utile per configurare il vostro kernel ed averne quindi uno di default funzionante, per poi escludere le caratteristiche che non desiderate.
 | Nota Bene |
|---|---|
Per poter utilizzare kmod (si veda la la sezione Caricare i moduli del Kernel nel Capitolo 3 per maggiori dettagli) ed i suoi moduli dovete rispondere Yes a kmod support ed a module version (CONFIG_MODVERSIONS) support. |
Se volete costruire un kernel con un file di configurazione (/usr/src/linux/.config che avete già creato con uno dei metodi precedenti, potete omettere i comandi make mrproper e make config ed usare il comando make dep seguito da make clean per preparare l'albero dei sorgenti per la compilazione.
Il passo successivo consiste semplicemente nel modificare /usr/src/linux/Makefile e nella compilazione del codice sorgente dei componenti che la vostra macchina utilizza per il boot. Il metodo qui descritto è il più facile per evitare inconvenienti. Per maggiori informazioni sulla compilazione del kernel, fate riferimento al Kernel-HOWTO oppure al Makefile presente nella /usr/src/linux del vostro sistema.
Modificate il Makefile e la linea EXTRAVERSION = per ottenere un nome "univoco" (per esempio aggiungendo le vostre iniziali alla fine della stringa: EXTRAVERSION = -2.5.0sjs). Questo vi consentirà di avere sul vostro sistema sia il vecchio kernel che quello nuovo.
Ricompilate il kernel con make bzImage.
Ricompilate i moduli che avete configurato con make modules.
Installate i nuovi moduli (anche se non ne avete ricompilati o modificati) con make modules_install. Verrano installati nella directory /lib/modules/ usando il percorso specificato nel file Makefile. Nel nostro esempio diventa /lib/modules/2.2.15-2.5.0sjs/.
Se possedete un controller SCSI e avete ricompilato il driver SCSI come modulo, create una nuova immagine initrd. Fate riferimento alla la sezione Preparazione di un'immagine initrd; tenete presente che ci sono diverse ragioni pratiche per impostare un driver SCSI modulare in un kernel personalizzato. A meno che non abbiate un motivo specifico per creare un'immagine initrd vi consigliamo di non farlo e quindi di non modificare il file lilo.conf.
Per avere a disposizione un modo sicuro per riavviare la macchina con un kernel funzionante, nel caso ci possa essere qualche errore nella configurazione del nuovo kernel, dovreste conservare il kernel originale. Per aggiungere una nuova label in LILO in modo da avviare il sistema con il nuovo kernel è necessario rinominare il kernel originale nella directory /boot, copiare il nuovo kernel in /boot, aggiungere alcune linee in /etc/lilo.conf e lanciare /sbin/lilo. Qui di seguito troverete un esempio di /etc/lilo.conf per Red Hat Linux:
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
message=/boot/message
linear
default=linux
image=/boot/vmlinuz-2.2.16-12
label=linux
initrd=/boot/initrd-2.2.16-12.img
read-only
root=/dev/hda8
other=/dev/hda1
label=dos |
Ora potete aggiornare /etc/lilo.conf. Se creerete una nuova immagine initrd dovrete aggiornare LILO in modo da utilizzarla. Nell'esempio successivo del file /etc/lilo.conf abbiamo aggiunto quattro linee per indicare un altro kernel tramite il quale poter avviare il sistema. Abbiamo rinominato /boot/vmlinuz in /boot/vmlinuz.old cambiando la sua label in old. Inoltre abbiamo aggiunto una nuova riga initrd per il nuovo kernel:
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
message=/boot/message
linear
default=linux
image=/boot/vmlinuz-2.2.16-12
label=linux
initrd=/boot/initrd-2.2.16-12.img
read-only
root=/dev/hda8
image=/boot/vmlinuz-2.2.16-12.sjs
label=test
initrd=/boot/initrd-2.2.16-12sjs.img
read-only
root=/dev/hda8
other=/dev/hda1
label=dos
|
Quando il sistema si avvia, premendo Tab al prompt LILO boot: verranno mostrate le scelte:
LILO boot:
linux test dos
|
Per avviare il sistema con il vecchio kernel digitate (linux) e premete Enter, o aspettate il time out di LILO. Se volete eseguire il boot con il nuovo kernel (test), digitate test e premete Enter.
Sintesi dei passi per la compilazione del kernel:
Copiate il kernel compilato nella vostra directory /boot cambiandogli nome. Ecco un esempio:
cp -p /usr/src/linux/arch/i386/boot/bzImage /boot/vmlinuz-2.2.15-2.5.0sjs /usr/src/linux/System.map /boot/System.map-2.2.15-2.5.0sjs
Modificate /etc/lilo.conf.
Preparate un'immagine, initrd (si veda la la sezione Preparazione di un'immagine initrd) se necessario.
Eseguite il comando /sbin/lilo. Potete utilizzare l'opzione -v con il comando lilo per avere informazioni più accurate per risolvere eventuali problemi.
Potete provare il vostro nuovo kernel facendo ripartire il sistema ed osservando se tra i messaggi che vengono visualizzati durante il boot viene rilevata qualche anomalia.
Preparazione di un'immagine initrd
Un'immagine initrd è necessaria per caricare il vostro modulo SCSI al momento dell'avvio. Se non vi serve un'immagine initrd non createla e non modificate lilo.conf per includerla.
Lo script /sbin/mkinitrd può costruire un'immagine corretta di initrd per il vostro sistema se le seguenti premesse vengono soddisfatte:
Il dispositivo loopback block è disponibile
Il file /etc/conf.modules ha una voce per il vostro controller SCSI per esempio:
alias scsi_hostadapter BusLogic
Per creare una nuova immagine initrd lanciate il comando /sbin/mkinitrd con i seguenti parametri:
/sbin/mkinitrd /boot/newinitrd-image 2.2.15-2.5.0sjs |
dove /boot/newinitrd-image è il file usato per la vostra nuova immagine, e 2.2.15 è la versione del kernel i cui moduli (da /lib/modules) vengono utilizzati per creare l'immagine initrd.
Ricompilare un kernel monolitico
Per ricompilare un kernel monolitico dovete seguire lo stesso procedimento che avete utilizzato per la ricompilazione di un kernel modulare, con alcune eccezioni.
Quando state configurando il kernel rispondete solo Yes e No alle opzioni. Dovreste anche rispondere No a kmod support e module version (CONFIG_MODVERSIONS) support durante la compilazione
Tralasciate i punti:
make modules make modules_installModificate lilo.conf ed aggiungete la linea append=nomemoduli.