codice:
+--------------------La compilazione del kernel bignamizzata-------------------+
Bisogna premettere che la compilazione, o la ricompilazione del kernel, spesso
non e' necessaria. E' possibile infatti scaricare i file binari gia' compilati
dal sito della propria distribuzione. Vista la crescita esponenziale delle
capacita' dell'hardware, la compilazione si rende utile o in presenza di
hardware non supportato, o per alcune vecchie macchine che hanno bisogno di
configurazioni "ad hoc" per il corretto funzionamento. Tuttavia essendo nello
spirito del sistema operativo e' possibile farlo anche solo per ottenere uno
snellimento del kernel, evitando riferimenti a hardware che non si possiede,
o a software per noi inutile. La compilazione e la ricompilazione del kernel non
portano a notevoli miglioramenti prestazionali, fatte salve le introduzioni
innovative che fanno testo a parte, infatti, vista la standardizzazione a cui
sono costrette per compatibilita' le distribuzioni, la maggior parte dei
pacchetti software sono compilati seguendo standard non certo ottimizati, per
permettere a tutti di usufruirne. Avremmo sicuramente piu' benefici con la
ricompilazione "in primis" delle principali librerie standard C (glibc,ecc),
e successivamente delle applicazioni piu' usate, ottimizzandole per il nostro
hardware, visto che sono quasi tutte compilate per i386, tipo di macchina un po'
in disuso, ma che definisce uno standard.
Non ultimo il problema delle versioni personalizzate, i kernel di molte
distribuzioni commerciali viene pesantemente modificato, nella red-hat, ma
anche nella mandrake vengono applicate piu' di 250 patch percui su questi
sistemi e' sconsigliabile usare il kernel originale disponibile su kernel.org
perche' le modifiche da apportare richiedono tempo e conoscenza, e qualche
applicazione o comando potrebbe avere strani comportamenti, insomma un
sistema potenzialmente instabile. Gli utenti Slackware potranno tranquillamente
usare i sorgenti originali, gli altri dovranno aspettare che la distribuzione
pubblichi i sorgenti e usare quelli.
Terminata questa piccola ma doverosa introduzione possiamo cominciare.
Dobbiamo per prima cosa creare un floppy di avvio del sistema, utile nel caso
qualche operazione non andasse a buon fine. Spesso un operazione di ripristino
puo' essere effettuata avviando la macchina con il cd di installazione della
propria distribuzione, avendo cura di abilitare l'avvio da cd-rom nel bios.
E' comunque molto piu' pratico avere un floppy di avvio, procedura che spesso
viene fatta dal processo d'installazione. Noi lo creeremo "ex novo".
Inserite un floppy nel lettore e dalla shell, o da un terminale digitate:
fdformat /dev/fd0H1440
il comando fdformat dovrebbe farvi vedere il suo output.
Se ricevete un messaggio di errore, probabilmente la vostra distribuzione adotta
una denominazione della periferica diversa. Per scoprirla digitate:
ls /dev/fd*
vi fara' vedere tutti i device che cominciano con fd (Floppy Drive) presenti
nella directory /dev del sistema, in genere il primo o il secondo funziona.
Finita la formattazione, possiamo usare il programma mkbootdisk per creare un
disco di avvio, gli utenti Slackware come me useranno il comando makebootdisk.
Questi programmi, spesso modificati a seconda della distribuzione cercheranno
il file vmlinuz-VERSIONE_KERNEL (vmlinuz per la Slackware) nella directory /boot
( / per la Slackware), VERSIONE_KERNEL e' in genere uguale al'output del comando
uname -r
digitatelo per sapere la vostra versione.
Vi consiglio di testare il disco di avvio facendo ripartire la macchina da
floppy.
Prima di fare qualsiasi operazione dobbiamo controllare alcune cose.
Portiamoci nella directory /usr/src con il comando
cd /usr/src
e controlliamo il contenuto con
ls -l
a questo punto davanti a voi avrete un file chiamato linux che altro non e' che
in collegamento simbolico che punta, o ai sorgenti del kernel installato, o alla
directory che ha lo stesso nome del kernel che contiene i file include, che
sonofile del kernel necessari al compilatore per compilare i sorgenti dei
programmi.Rimuoviamo questo file con il comando
rm linux
Con questo non rimuoveremo nessuna directory ma solo il collegamento, lo
facciamo perche' quando decomprimeremo il nuovo kernel verra' creata quasi
sempre, tranne i kernel disponibili solo per alcune distribuzioni a cui vengono
applicate alcune patch o correzioni che vengono numerati sequenzialmente, una
cartella chiamata linux, ma lo vedremo in seguito.
Se non fossero presenti i sorgenti ma solo la cartella dei file include e'
ovvio che non possiamo ricompilare sorgenti che non abbiamo, dovremo trovare
i sorgenti per compilarci un nuovo kernel.
Essendo i moderni kernel modulari, consentono cioe' il caricamento di moduli,
generalmente driver, successivamente all'avvio, quando noi compiliamo o
ricompiliamo il kernel dovremo gestire piu' file, il kernel vero e proprio e
numerosi altri file come i moduli di solito con estensione .o oppure .o.gz che
verranno installati nella cartella /lib/modules/VERSIONE_KERNEL, oltre al file
System.map che rappresenta una sorta di instantanea del sistema reponsabile
spesso del fatidico messaggio
kernel: Symbol table has incorrect version number
Quando noi compiliamo un kernel di versione differente da quello installato
i moduli verranno copiati in /lib/modules/VERSIONE_KERNEL, differendo le
versioni non verranno toccati i precedenti moduli...ma se ricompiliamo il
kernel gia' installato? In questo caso dovremo mettere al sicuro i file
funzionanti per permetterci di ripristinare lo "status quo antea". Per farlo
dobbiamo fare una copia di riserva dei nostri file. Portiamoci nella directory
dei moduli e facciamocene una copia digitando
cd /lib/modules
ls
nel mio caso l'output e'
2.4.17/
facciamoci una copia digitando
tar cfv modules.tar 2.4.17/
ovviamente sostituite il numero di versione con il vostro. Dato che abbiamo
usato l'opzione "v" del comando tar vi passeranno davanti tutti i file, finita
l'esecuzione del comando avremo una copia di ripristino perche' l'installazione
dei moduli sovrascrivera' la directory in caso di ricompilazione. C'e' anche
un'altra strada ma per le prime volte ve la sconsiglio (lo so e' come se vi
avessi detto fatela..), si potrebbe una volta scompressi i file sorgenti del
kernel modificare il file "Makefile" nella riga che definisce la variabile
EXTRAVERSION, se modificassi la variabile cosi':
EXTRAVERSION = PP
dove PP sono semplicemente le mie iniziali e otterrei in fase di installazione
la creazione della cartella /lib/modules/VERSIONE_KERNEL-PP evitando di
sovrascrivere la cartella gia' presente. Non modificate altre variabili che si
riferiscono alla versione perche' sono usate da altre applicazioni.
Per compilare il kernel il vostro sistema deve soddisfare i requisiti minimi
definiti nella cartella (che ancora non creiamo)
/usr/src/linux/Documentation/Changes
nella sezione Current Minimum Requirements. Molti di questi pacchetti sono
installati in molti sistemi, ma a scanso si equivoci e' meglio controllare che
ci siano nel proprio sistema.
+--Software--+----+--per controllare da shell--+----------------+
| Gnu C # gcc --version |
| Gnu make # make --version |
| binutils # ld -v |
| util-linux # fdformat --version |
| modutils # insmod -V |
| e2fsprogs # tune2fs |
| PPP # pppd --version |
| isdn4k-utils # isdnctrl 2>&1|grep version |
+---------------------------------------------------------------+
Per installare i sorgenti esistono diversi metodi a seconda del formato in cui
saranno impacchettati, se red-hat o simili avremo un file con estensione .rpm,
per altri sara' un normalissimo file con estensione .tar.gz o simili.
Per usare gli strumenti di configurazione del kernel un tantino piu' evoluti
del semplice "config" da riga di comando, devono essere installate (normalmente
ci sono) le librerie ncurses per il comando "menuconfig" oppure il server
grafico XFree per usare il comando "xconfig". Se dovessimo applicare delle patch
al kernel queste andranno chiaramente applicate successivamente l'installazione
dei sorgenti, e prima della compilazione. Ammettiamo che abbiate i sorgenti del
kernel in formato .tar.gz . Per farla semplice copiamo il file nella directory
che normalmente contiene i sorgenti (ricordarsi di cancellare il collegamento
di cui abbiamo parlato prima) digitando
cp VERSIONE_KERNEL.tar.gz /usr/src
poi ci rechiamo in suddetta cartella con
cd /usr/src
e lo scomprimiamo con
tar xvzf VERSIONE_KERNEL.tar.gz
ci creera' una cartella, normalmente chiamata linux rinominiamola con la
versione corrente e ricreiamo il collegamento simbolico linux che cosi' puntera'
alla versione appena installata
mv linux linux-VERSIONE_KERNEL
ln -s linux-VERSIONE_KERNEL linux
se a questo punto abbiamo bisogno di applicare patch dobbiamo rispettare
l'ordine di rilascio dal piu' basso al piu' alto, per esempio
cp patch01.gz /usr/src/linux
cd /usr/src/linux
gunzip patch01.gz
patch -p1 < patch01
o piu' sinteticamente
cd /usr/src gzip -cd patch01.gz | patch -p0
o per il formato bzip
cd /usr/src bunzip2 -dc patch01.bz2 | patch -p0
Bisognera' ripetere il procedimento per tutte le patch in ordine stando
attenti all'eventuale creazione di file .rej (rejected, rifiutato) che
indicherebbero errori nell'applicazione della patch. Esiste anche uno script
che automatizza la procedura cercando nella directory tutti i file patch da voi
scompressi al suo interno.
cd /usr/src/linux/scripts
./patch-kernel
segue in basso...
Rispondi quotando