LKN: Installare ed Avviare con un Kernel: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
m (spostata TOC)
m (link)
 
(11 versioni intermedie di 5 utenti non mostrate)
Riga 1: Riga 1:
{{LKN}}
__TOC__
__TOC__


Ora che avete scaricato i sorgenti della versione del kernel che avete scelto e che li avete installati in una cartella locale, � giunto il momento di compilare il codice. Il primo passo � di configurare il kernel con le opzioni appropriate; in seguito il kernel potr� essere compilato. Entrambe le operazioni sono portate a termine attraverso lo strumento standard ''make''.
I precedenti capitoli hanno mostrato come scaricare e compilare il kernel. Ora che si ha un file eseguibile -- con tutti i moduli compilati -- è ora di installare il kernel e provare a fare il boot. In questo capitolo, a differenza dei precedenti, tutti i comandi necessitano di essere eseguiti come utente root. Questo  può essere fatto anteponendo ad ogni comando ''sudo'', usando il comando ''su'' per diventare root, oppure accedendo come ''root''.


== '''Creare una Configurazione''' ==
Per vedere se si ha ''sudo'' installato e gli appropriati diritti di accesso, lanciate:
<pre>
$ sudo ls ~/linux/linux-2.6.17.11/Makefile
Password:
Makefile
</pre>
Inserite la vostra password personale al prompt di password, o la password dell'amministratore di sistema (root). La scelta dipende da come il comando di ''sudo'' è stato impostato. Se non ci sono problemi, e si vede una riga che contiene:
<pre>Makefile</pre>
allora potete passare alla prossima sezione.


La configurazione del kernel risiede in un file chiamato ''.config'' nella cartella principale dell'albero dei sorgenti del kernel. Se avete appena estratto il codice sorgente del kernel, non vi sar� alcun file ''.config'', quindi dovr� essere creato. Il file pu� essere creato da zero, creato partendo dalla "configurazione predefinita", preso da una versione funzionante del kernel, o preso da quello rilasciato da una distribuzione. Copriremo i primi due metodi adesso, gli ultimi due metodi nel [[LKN:_Personalizzare_un_Kernel|Capitolo 7]].
Se ''sudo'' non è installato o non si hanno i diritti appropriati, si provi ad usare il comando ''su'':
<pre>
$ su
Password:
# exit
exit
$
</pre>
Al prompt della password, inserite la password dell'amministratore di sistema (''root''). Quando ''su'' accetta con successo la password, si è trasferiti ad eseguire ogni cosa con i pieni privilegi di root. State molto attenti mentre siete ''root'', e fate solo il minimo necessario; dopodiché uscite dal programma per tornare con il vostro utente normale.


==='''Configurare dall'inizio'''===
== Usare uno script di installazione di una distribuzione ==
Il modo pi� spartano per configurare un kernel � usare il metodo ''make config'':
Quasi tutte le distribuzioni hanno uno script chiamato ''installkernel'' che può essere usato dal sistema di creazione del kernel per installarne uno pronto automaticamente nel giusto posto e per modificare il bootloader così che nulla di più debba essere fatto dallo sviluppatore<sup>*</sup>.
<pre>$ cd linux-2.6.17.10
  $ make config
make config
scripts/kconfig/conf arch/i386/Kconfig
*
* Linux Kernel Configuration
*
*
* Code maturity level option
*
Prompt for development and/or incomplete code/drivers (EXPERIMENTAL) [Y/n/?]
Y


*
[[Image:Warning_65x68.jpg|left|caption]] Le distribuzioni offrono ''installkernel'' solitamente in un pacchetto chiamato ''mkinitrd'', provate ad installare questo pacchetto se non trovate lo script sulla vostra macchina. <br clear=all/>
* General setup
*
Local version - append to kernel release (LOCALVERSION) []
Automatically append version information to the version string
(LOCALVERSION_AUTO) [Y/n/?] Y
...</pre>
Il programma di configurazione del kernel proceder� attraverso ogni opzione di configurazione e chieder� se la si vuole abilitare o meno. Tipicamente, le possibilit� per ogni opzione sono presentate nella forma <tt>[Y/m/n/?]</tt>. La lettera maiuscola � la scelta predefinita, e pu� essere selezionata semplicemente premendo il tasto Invio. Le quattro scelte sono:
* <tt>Y</tt>  Compilare direttamente nel kernel.
* <tt>n</tt>  Lasciare completamente al di fuori del kernel.
* <tt>m</tt>  Compilare come modulo, da caricare se necessario.
* <tt>?</tt>   Stampa un breve messaggio descrittivo e ripropone il quesito.
Il kernel contiene quasi duemila opzioni di configurazioni differenti, quindi rispondere ad una domanda su ognuna di esse richiede un notevole dispendio di tempo. Fortunatamente, vi � un modo pi� facile di configurare un kernel: basare la configurazione su di un'altra precostituita.


==='''Opzioni della Configurazione predefinita'''===
Se avete compilato qualsiasi modulo e volete usare questo metodo per installare un kernel, inserite:
Ogni versione del kernel ha una configurazione "predefinita". Questa configurazione � in parte basata sulle scelte che il responsabile di quella architettura crede siano le opzioni migliori da essere usate. In alcuni casi, � la configurazione usata dal responsabile stesso sulle proprie macchine. Questo � vero per l'architettura i386, dove la configurazione predefinita corrisponde strettamente a quella che Linus Torvalds usa per la sua macchina di sviluppo principale.
<pre># make modules_install</pre>
Questo installerà tutti i moduli che avete compilato e li metterà nelle appropriate locazioni del filesystem per farli trovare correttamente dal nuovo kernel. I moduli sono posti in ''/lib/modules/kernel_version'', dove per ''kernel_version'' si intende la versione del nuovo kernel che avete appena compilato.


Per creare questa configurazione predefinita, eseguite:
Dopo che i moduli sono stati installati con successo, l'immagine principale del kernel deve essere installata:
<pre>$ cd linux-2.6.17.10
<pre># make install</pre>
$ make defconfig</pre>
Ciò farà partire il seguente processo:
Un'enorme quantit� di opzioni di configurazione scorrer� velocemente sullo schermo, e un file ''.config'' sar� creato e piazzato nella cartella del kernel. Il kernel � ora correttamente configurato, ma dovrebbe essere adattato alla vostra macchina per assicurarsi che funzioni correttamente.
# Il sistema di compilazione del kernel verificherà che il kernel sia stato correttamente compilato.
# Il sistema di compilazione copierà la parte statica nella directory ''/boot'' e rinominerà l'eseguibile sulla base della versione del kernel.
# Qualsiasi immagine di ramdisk iniziale necessaria verrà creata automaticamente, usando i moduli che sono appena stati installati durante la fase di ''modules_install''.
# Al programma di bootloader verrà correttamente notificato che un nuovo kernel è presente, e verrà aggiunto nel giusto menu così che l'utente possa selezionarlo la prossima volta che la macchina verrà avviata.
# Dopo questo ha finito, il kernel è installato con successo, si può tranquillamente riavviare e provare la nuova immagine di kernel. Notare che questa installazione non sovrascrive nessuna vecchia immagine dei kernel, così se c'è un problema con la vostra nuova immagine del kernel, il vecchio kernel potrà essere selezionato al tempo d'avvio (''boot time'').


==='''Modificare la configurazione'''===
<small>Nota ('''<sup>*</sup>'''): eccezioni da riportare a questa regola sono Gentoo e altre distribuzioni tipo "from scratch", le quali si
Ora che abbiamo un file di configurazione di base, dovrebbe essere modificato per supportare l'hardware presente nel vostro sistema. Per ulteriori dettagli su come individuare quali opzioni siano necessarie per ottenere ci�, potete leggere il [[LKN:_Personalizzare_un_Kernel|Capitolo 7]]. Qui mostreremo come selezionare le opzioni che potreste voler cambiare.
aspettano che l'utente sappia come installare i kernel da solo. Questi tipi di distribuzioni includono la
documentazione su come installare un nuovo kernel, si consulti quest'ultima per l'esatto metodo richiesto.</small>


Ci sono tre differenti strumenti interattivi per la configurazione del kernel: uno basato su terminale chiamato ''menuconfig'', uno grafico basato sulle GTK+ chiamato ''gconfig'', e un altro grafico basato sulle QT chiamato ''xconfig''.
== Installazione manuale ==
Se la distribuzione non è provvista del comando ''installkernel'', o si desidera semplicemente fare il lavoro a mano per capire i passi che servono, eccoli qua:


==='''Configurazione tramite Terminale'''===
I moduli devono essere installati:
Il metodo chiamato '''menuconfig''' per configurare un kernel � un programma per terminale che d� modo di muoversi nella configurazione del kernel usando i tasti freccia della tastiera. Per avviare questa modailt� di configurazione, digitate:
<pre># make modules_install</pre>
<pre>$ make menuconfig</pre>
Vi apparir� una schermata molto simile a quella di figura 4-1.


[[Immagine:Menuconfig_1.png|frame|''Figura 4-1. Schermata iniziale di menuconfig'']]
L'immagine statica del kernel deve essere copiata nella directory ''/boot''. Per un kernel basato su piattaforma i386, fare:
<pre> 
# make kernelversion
2.6.17.11
</pre>


Notare che la versione del kernel probabilmente sarà differente da quella del vostro. Usate questo valore al posto del testo KERNEL_VERSION nei seguenti passaggi:
<pre>
# cp arch/i386/boot/bzImage /boot/bzImage-KERNEL_VERSION
# cp System.map /boot/System.map-KERNEL_VERSION
</pre>


Le istruzioni per navigare attraverso il programma, e i significati dei diversi caratteri, sono mostrati in cima allo schermo. Il resto dello schermo contiene le diverse opzioni di configurazine.
Modificare il bootloader in modo che conosca il nuovo kernel. Questo implica modificare il file di configurazione per il bootloader che si usa, è spiegato più avanti in "Modificare il bootloader per il nuovo kernel" in GRUB e LILO.


La configurazione del kernel � divisa in sezioni. Ogni sezione contiene opzioni che corrispondo ad argomenti specifici. Al loro interno possono esserci sottosezioni per vari argomenti specifici. Per esempio tutti i driver per le periferiche possono essere trovati sotto l'opzione del menu principale <tt>Device Drivers ---></tt>. [[Immagine:Menuconfig_2.png|frame|''Figura 4-2. Selezione dell'opzione Device Drivers'']]
Se il processo di avvio non funziona, solitamente è perché una immagine iniziale di ramdisk (initial ramdisk) è necessaria. Per crearla correttamente, si usino i passi all'inizio di questo capitolo per installare un kernel automaticamente, poich&eacute; lo script di installazione della distribuzione sa come creare adeguatamente il ramdisk usando gli script e gli strumenti necessari. Dato che ogni distribuzione fa questo in maniera differente, è oltre lo scopo di questo libro ricoprire tutti i differenti metodi di costruzione dell'immagine di ramdisk.
Per aprire questo menu, premete la freccia in basso nove volte, finch� la linea <tt>Device Drivers ---></tt> non � sottolineata, come mostrato in figura 4-2.


Premete poi il tasto Invio. Vi porter� nel sotto-menu <tt>Device Drivers</tt> e lo mostrer� come mostrato nella figura 4-3.
Qui c'è uno script comodo che può essere usato per installare un kernel automaticamente invece di dover digitare tutti i precedenti comandi ogni volta:
<pre>
#!/bin/sh
#
# installs a kernel
#
make modules_install


[[Immagine:Menuconfig_3.png|frame|''Figura 4-3. Sottomenu Device Drivers'']]
# find out what kernel version this is
for TAG in VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION ; do
  eval `sed -ne "/^$TAG/s/ //gp" Makefile`
done
SRC_RELEASE=$VERSION.$PATCHLEVEL.$SUBLEVEL$EXTRAVERSION


# figure out the architecture
ARCH=`grep "CONFIG_ARCH " include/linux/autoconf.h | cut -f 2 -d "\""`


Potete continuare a muovervi nella gerarchia dei menu allo stesso modo. Per visualizzare il sotto-menu <tt>Generic Driver Options</tt> premete Invio di nuovo, e vedrete se tre opzioni mostrate in figura 4-4.
# copy the kernel image
cp arch/$ARCH/boot/bzImage /boot/bzImage-"$SRC_RELEASE"


[[Immagine:Menuconfig_4.png|frame|''Figura 4-4. Sottomenu Generic Driver Options'']]
# copy the System.map file
cp System.map /boot/System.map-"$SRC_RELEASE"


echo "Installed $SRC_RELEASE for $ARCH"
</pre>


Le prime due opzioni hanno un simbolo <tt>[*]</tt> vicino a esse. Questo significa che quest'opzione � selezionata (perch� il simbolo <tt>*</tt> sta al centro dei due caratteri <tt>[]</tt>), e che questa � un'opzione del tipo s�-o-no. La terza opzione ha un segno <tt>< ></tt>, che mostra che questa opzione pu� essere inserita nel kernel (<tt>Y</tt>), compilata come modulo (<tt>M</tt>), o esclusa del tutto (<tt>N</tt>).
==  Modificare il bootloader per il nuovo kernel ==
Esistono due bootloader comuni per i kernel Linux: GRUB e LILO. GRUB è quello maggiormente usato nelle distribuzioni moderne, e fa alcune cose un po' più facilmente di LILO, ma LILO è ancora utilizzato. Li vedremo entrambi in questa sezione.


Se l'opzione � selezionata con <tt>Y</tt>, le parentesi ad angolo conterranno un <tt>*</tt>. Se � selezionata come modulo con una <tt>M</tt>, conterranno una lettera <tt>M</tt>. Se � disabilitata con <tt>N</tt>, mostreranno solo uno spazio bianco.
Per determinare quale bootloader il vostro sistema usa, guardate nella directory ''/boot/''. Se esiste una sottodirectory ''grub'':
<pre>
$ ls -F /boot | grep grub
grub/
</pre>
allora si sta utilizzando GRUB come programma per fare il boot. Se questa directory non è presente, si guardi se è presente il file ''/etc/lilo.conf'':
<pre>
$ ls /etc/lilo.conf
/etc/lilo.conf
</pre>
se è presente, state usando LILO come programma per fare il boot.


Cos�, se desiderate cambiare queste tre opzioni per selezionare solo driver che non necessitano di firmware esterno in tempo di compilazione, disabilitate l'opzione per impedire che il firmware sia compilato, e compilate il caricatore del firmware in spazio utente come modulo, digitando <tt>Y</tt> per la prima opzione, <tt>N</tt> per la seconda e <tt>M</tt> per la terza, rendendo la schermata come quella in figura 4-5.
I passi che implicano l'aggiunta del nuovo kernel a ognuno di questi programmi sono differenti, per cui si segua solo la sezione che corrisponde al programma che si sta usando.


[[Immagine:Menuconfig_5.png|frame|''Figura 4-5. Sottomenu Generic Driver Options cambiato'']]
==='''GRUB'''===
Per fare in modo che GRUB sappia che un nuovo kernel è presente, tutto ciò che dovete fare è modificare il file ''/boot/grub/menu.lst''. Per i dettagli completi della struttura di questo file, e tutte le differenti opzioni disponibili, consultate le pagine di info di GRUB:
<pre>$ info grub</pre>


Il metodo più facile per aggiungere una nuova voce kernel a ''/boot/grub/menu.lst'' è quello di copiare una voce già esistente. Per esempio, considerate il seguente ''menu.lst'' da un sistema Gentoo:
<pre>
timeout 300
default 0


Quando avete completato le vostre modifiche in questa schermata, premete il tasto Esc o la freccia destra seguita dal tasto Invio per lasciare questo sottomenu. Tutte le opzioni del kernel possono essere esplorate in questa maniera.
splashimage=(hd0,0)/grub/splash.xpm.gz


Quando avete finito di fare tutte le modifiche che desideriate apportare alla configurazione del kernel, uscite dal programma premendo il tasto Esc quando siete nel menu principale.
title 2.6.16.11
[[Immagine:Menuconfig_6.png|frame|''Figura 4-6. Salvare le opzioni del kernel'']]
  root (hd0,0)
Vi sar� mostrata la schermata in figura 4-6, che vi chiede se desiderate salvare la vostra modificata configurazione.
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305


Premete Invio per salvare la configurazione, o, se volete eliminare ogni modifica fatta, digitate la freccia destra per selezionare la voce <tt>< No ></tt> e premete Invio.
title 2.6.16
  root (hd0,0)
  kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305
</pre>


La linea che comincia con la parola title definisce una nuova voce di kernel, in questo modo questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con la linea title, come:
<pre>
title 2.6.16.11
  root (hd0,0)
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305
</pre>


Dopodiché aggiungete il blocco alla fine del file, e modificate il numero di versione con la nuova versione del nuovo kernel che si è appena installato. Il titolo non ha alcuna importanza, purché unico, ma visualizzato nel menu di boot, per cui si dovrebbe dargli qualcosa che abbia un significato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per tanto la copia finale del file assomiglierà a:
<pre>
timeout 300
default 0


==='''Metodi grafici di configurazione'''===
splashimage=(hd0,0)/grub/splash.xpm.gz
I metodi di configurazione del kernel ''gconfig'' e ''xconfig'' usano un programma grafico per permettervi di modificare la configurazione. I due metodi sono pressoch� identici, l'unica differenza risiedendo nei diversi strumenti grafici attraverso i quali sono scritti. ''gconfig'' � scritto usando il toolkit GTK+ e ha uno schermo diviso in due regioni, come mostrato in figura 4-7.


[[Immagine:Gconfig_1.png|740px|thumb|''Figura 4-7. Schermata di make gconfig'']]
title 2.6.16.11
  root (hd0,0)
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305


title 2.6.16
  root (hd0,0)
  kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305


Il metodo ''xconfig'' � scritto usando il toolkit QT e ha uno schermo diviso in tre regioni, come in figura 4-8.
title 2.6.17.11
  root (hd0,0)
  kernel /bzImage-2.6.17.11 root=/dev/sda2 vga=0x0305
</pre>


[[Immagine:Xconfig_1.png|740px|thumb|''Figura 4-8. Schermata di make xconfig'']]
Dopo che si è salvato il file, riavviate il sistema e assicuratevi che il titolo della nuova immagine del kernel sia presente nel menu di boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, e premete enter per avviare la nuova immagine.


==='''LILO'''===
Per fare in modo che LILO sappia che un nuovo kernel è presente, dovete modificare il file di configurazione ''/etc/lilo.conf'' ed eseguire il comando ''lilo'' per applicare le modifiche fatte al file di configurazione. Per i dettagli completi sulla struttura del file di configurazione di LILO, consultate la manpage di LILO:
<pre>$ man lilo</pre>


Usate il mouse per navigare nei sottomenu e selezionare le opzioni. Per esempio, nella figura 4-8 potreste usarlo per selezionare il sottomenu <tt>Generic Driver Options</tt> del menu <tt>Device Drivers</tt>. Questo cambier� la schermata di ''xconfig'' e la far� diventare quella dell'immagine 4-9.  
Il modo pi&ugrave; facile per aggiungere una nuova voce di kernel nel file ''/etc/lilo.conf'' è copiare una voce esistente. Per esempio, considerate il seguente file di configurazione di LILO di un sistema Gentoo:
<pre>
boot=/dev/hda
prompt
timeout=50
default=2.6.12


[[Immagine:Xconfig_2.png|740px|thumb|''Figura 4-9. Generic Driver Options in make xconfig'']]
image=/boot/bzImage-2.6.15
  label=2.6.15
  read-only
  root=/dev/hda2


La corrispondente immagine di ''gconfig'' � in figura 4-10.
image=/boot/bzImage-2.6.12
  label=2.6.12
  read-only
  root=/dev/hda2
</pre>


[[Immagine:Gconfig_2.png|740px|thumb|''Figura 4-10. Generic Driver Options in make gconfig'']]
La linea che comincia con la parola image= definisce una nuova voce kernel, quindi questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con image=, come:
<pre>
image=/boot/bzImage-2.6.15
  label=2.6.15
  read-only
  root=/dev/hda2
</pre>


Modificare questo sottomenu per disabilitare la seconda opzione e rendere la terza opzione compilata come modulo genera le schermate apparire come nelle figure 4-11 e 4-12.
Aggiungete dopo il blocco alla fine del file, e modificate il numero di versione per contenere quella del nuovo kernel appena installato. La label non ha alcuna importanza, purché unica, ma è visualizzata nel menu di boot, per cui dovreste dargli qualcosa di sensato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per cui la copia finale del file sarà:
<pre>
boot=/dev/hda
prompt
timeout=50
default=2.6.12


[[Immagine:Xconfig_3.png|740px|thumb|''Figura 4-11. Generic Driver Options in make xconfig, modificato'']]
image=/boot/bzImage-2.6.15
[[Immagine:gconfig_3.png|740px|thumb|''Figura 4-12. Generic Driver Options in make gconfig, modificato'']]
  label=2.6.15
Notate che nel metodo ''gconfig'' un riquadro con il segno di visto significa che l'opzione sar� compilata nel kernel, laddove una linea nel riquadro significa che l'opzione sar� compilata come modulo. Nel metodo ''xconfig'' un'opzione compilata come modulo sar� mostrata con un punto nel riquadro.
  read-only
  root=/dev/hda2


Entrambi questi metodi vi chiedono di salvare la configurazione quando uscite dal programma, e offrono la possibilit� di scrivere quella configurazione in un altro file. Potete cos� creare molteplici, distinte configurazioni.
image=/boot/bzImage-2.6.12
  label=2.6.12
  read-only
  root=/dev/hda2


image=/boot/bzImage-2.6.17
  label=2.6.17
  read-only
  root=/dev/hda2
</pre>
Dopo aver salvato il file, lanciate il programma ''/sbin/lilo'' per salvare i cambiamenti del file di configurazione nella sezione di boot del disco:
<pre># /sbin/lilo</pre>
Ora il sistema può essere riavviato in sicurezza. La scelta del nuovo kernel si può vedere tra le scelte disponibili al momento del boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, premete Invio per avviare la nuova immagine.


=='''Compilazione del Kernel'''==
Ora che avete creato la configurazione che intendete usare, dovete compilare il kernel. Questo semplice come digitare un comando di un parola:
<pre>$ make
CHK include/linux/version.h
UPD include/linux/version.h
SYMLINK include/asm -> include/asm-i386
SPLIT include/linux/autoconf.h -> include/config/*
CC arch/i386/kernel/asm-offsets.s
GEN include/asm-i386/asm-offsets.h
CC scripts/mod/empty.o
HOSTCC scripts/mod/mk_elfconfig
MKELF scripts/mod/elfconfig.h
HOSTCC scripts/mod/file2alias.o
HOSTCC scripts/mod/modpost.o
HOSTCC scripts/mod/sumversion.o
HOSTLD scripts/mod/modpost.o
HOSTCC scripts/kallsyms
HOSTCC scripts/conmakehash
HOSTCC scripts/bin2c
CC init/main.o
CHK include/linux/compile.h
UPD include/linux/compile.h
CC init/version.o
CC init/do_mounts.o
...</pre>


Eseguire ''make'' fa s� che il sistema di compilazione del kernel usi il file di configurazione che avete selezionato per compilare un kernel e tutti i moduli necessari per supportare tale configurazione. Mentre il kernel � in compilazione, ''make'' mostra cosa sta correntemente succedendo ai singoli file, insieme a tutti gli avvertimenti ("warnings", N.d.T.) e gli errori di compilazioni.
----
This is an indipendent translation of the book [http://www.kroah.com/lkn/ Linux Kernel in a Nutshell] by [http://www.kroah.com/log/ Greg Kroah-Hartman]. This translation (like the original work) is available under the terms of [http://creativecommons.org/licenses/by-sa/2.5/ Creative Commons Attribution-ShareAlike 2.5].
----


Se la compilazione del kernel termina senza errori, avete creato con successo l'immagine di un kernel. Comunque deve essere propriamente installata prima che proviate ad avviarla. Leggete il [[LKN:_Installare_ed_Avviare_con_un_Kernel|Capitolo 5]] per sapere come fare.


� molto raro avere errori di compilaizone quando state compilando una versione del kernel rilasciata. Se vi capita, riportateli agli sviluppatori del kernel Linux cosicch� possano essere corretti.
[http://files.kroah.com/lkn/lkn_pdf/ch05.pdf ''Capitolo originale'']


nota: Versioni del kernel pi vecchie, precedenti al rilascio 2.6 richiedevano l'ulteriore passo ''make modules'' per compilare tutti i moduli necessari. Questo non pi necessario.


=='''Opzioni di Compialzione avanzate'''==
[[Categoria:Documentazione tecnica]]
Il sistema di compilazione del kernel consente di fare molte altre cose, oltre a compilare l'intero kernel e i relativi moduli. Il Capitolo 10 contiene l'intero elenco delle opzioni che il sistema di compilazione fornisce. In questa sezione discuteremo alcune di queste opzioni avanzate. Per avere una descrizione completa di come usare altre opzioni avanzate, fate riferimento alla documentazione dentro il kernel stesso, che pu� essere trovata nella cartella ''Documentation/kbuild'' nei sorgenti.
[[Categoria:Linux Kernel in a Nutshell]]
 
==='''Velocizzare la Compilazione in Macchine Multiprocessore'''===
Il sistema di compilazione del kernel lavora molto bene come operazione che pu� essere divisa in pezzi pi� piccoli e assegnati a diversi processori. Facendo questo, potete usare la piena potenza di una macchina multiprocessore e ridurre considerevolmente il tempo di compilazione del kernel.
 
Per compilare un kernel in modo parallelo, usate l'opzione ''-j'' del comando ''make''. � meglio dare un numero all'opzione ''-j'' che corrisoponda al doppio del numero di processori nel sistema. Quindi, per macchine con due processori, usate:
<pre>$ make -j4</pre>
e per macchine con quattro processori, usate:
<pre>$ make -j8</pre>
Se non passate un numero all'opzione ''-j'':
<pre>$ make -j</pre>
il sistema di compilazione creer� un nuovo filo ("thread", N.d.T.) per ogni sottocartella nell'albero delle cartelle del kernel, che pu� facilmente rendere la vostra macchina non in grado di rispondere ai comandi, e impiegare molto pi� tempo per completare la compilazione. Per questo si raccomanda di passare sempre un valore numerico all'opzione ''-j''.
 
==='''Compilare solo una parte del kernel'''===
Quando ci si dedica allo sviluppo del kernel, a volte si desidera compilare solo una specifica sottocartella, o un singolo file dell'intero albero del kernel. Il sistema di compilazione lo consente agevolmente. Per compilare selettivamente una sottocartella, specificatela nel comando di compilazione. Per esempio, per compilare i file nella cartella '''drivers/usb/serial''', inserite: <pre>$ make drivers/usb/serial</pre>
Usando questa sintassi, comunque, non si compiler� l'immagine finale del modulo in quella cartella. Per fare questo, potete usare l'opzione <tt>M=</tt>argomento:<pre>$ make M=drivers/usb/serial</pre>che compiler� tutti i file necessari in quella cartella e collegher� le immagini finali dei moduli.
 
Quando si compila una singola cartella in uno dei modi mostrati, l'immagine finale del kernel non viene ricollegata. Comunque ogni cambiamento che era stato effettuato alle sottocartelle non influenzer� l'immagine finale del kernel, che probabilmente non � quello che desiderate. Eseguite alla fine un:<pre>$ make</pre> perch� il sistema di compilazione controlli tutti i file oggetto cambiati e colleghi in modo proprio l'immagine finale del kernel.
 
Per compilare un solo specifico file nell'albero del kernel, semplicemente passatelo come parametro a ''make''. Per esempio, se desiderate compilare il modulo ''drivers/usb/serial/visor.ko'', inserite:<pre>$ make drivers/usb/serial/visor.ko</pre>
Il sistema di compilazione compiler� tutti i file necessari per il modulo visor.ko, e far� il collegamento finale per creare il modulo.
 
==='''Sorgente in un posto, Destinazione in un altro'''===
Alle volte � pi� semplice avere i sorgendi del kernel in un posto accessibile in sola lettura (come un CD-ROM, o in un sistema di controllo del codice sorgene), e collocare l'output della compilazione altrove, cos� da non alterare l'albero originale del sorgente. Il sistema di compilazione lo realizza facilmente, richiedendo il solo argomento <tt>O=</tt> per specificare dove collocare l'output della compilazione. Per esempio se i sorgenti del kernel sono in un CD-ROM montato in ''/mnt/cdrom/'' e desiderate mettere i file compilati nella vostra cartella locale, inserite:<pre>$ cd /mnt/cdrom/linux-2.6.17.11
$ make O=~/linux/linux-2.6.17.11</pre>
Tutti i file compilati saranno creati nella cartella ''~/linux/linux-2.6.17.11''. Notate che questa opzione <tt>O=</tt> dovrebbe essere passata anche alle opzioni di configurazione della compilazione cosicch� la configurazione sia correttamente collocata nella cartella di destinazione e non in quella contenente il codice sorgente.
 
==='''Architetture differenti'''===
Una caratteristica molto utile � la costruzione di un kernel in una compilazione incrociata, per permettere a una macchina pi� potente di compilare un kernel per una sistema integrato pi� piccolo, o anche solo per controllare una compilazione per un'architettura diversa per assicurare che a un cambiamento nel codice sorgente non rompa qualcosa di inaspettato. Il sistema di compilazione del kernel consente di specificare un'architettura diversa da quella della macchina corrente con il parametro <tt>ARCH=</tt>argomento. Il sistema di compilazione consente, inoltre, di specificare il compilatore che si desidera usare con il parametro <tt>CC=</tt>argomento o uno stumento per concatenare ("toolchain", N.d.T.) la compilazione incrociata con <tt>CROSS_COMPILE</tt> argomento.
 
Per esempio, per avere la configurazione predefinita dell'architettura x86_64, si pu� inserire:<pre>$ make ARCH=x86_64 defconfig</pre>
Per compilare l'intero kernel con uno strumento per concatenare la compilazione situato in ''/usr/local/bin'', si pu� inserire:<pre>$ make ARCH=arm CROSS_COMPILE=/usr/local/bin/arm-linux-</pre>
� utile anche per i kernel non ottenuti con compilazione incrociata cambiare ci� il sistema di costruzione del kernel usa per il compilatore. Esempi di questo sono l'utilizzo dei programmi ''distcc'' o ''ccache'', i quali riducono notevolmente il tempo di compilazione di un kernel. Per usare il programma ''ccache'' come parte del sistema di costruzione del kerne, digitate:<pre>$ make CC="ccache gcc"</pre>.
Per usare entrambi i ''distcc'' e ''ccache'' insieme, inserite:<pre>$ make CC="ccache distcc"</pre>
[[Immagine:Example.jpg]]
 
 
[[Categoria:Kernel]]

Versione attuale delle 12:39, 14 mag 2016

Linux Kernel in a Nutshell

Sommario

Parte I
Compilare il kernel
  1. Introduzione
  2. Requisiti
  3. Procurarsi i sorgenti
  4. Configurazione e compilazione
  5. Installazione e avvio
  6. Aggiornare il kernel
Parte II
Personalizzazioni principali
  1. Personalizzare un kernel
  2. Ricette per configurare un kernel
Parte III
Guide di riferimento per il kernel
  1. Guida di riferimento dei parametri di boot del kernel - parte1
  2. Guida di riferimento dei parametri di boot del kernel - parte2
  3. Guida di riferimento dei parametri di compilazione del kernel
  4. Guida di riferimento delle opzioni di configurazione del kernel - parte1
  5. Guida di riferimento delle opzioni di configurazione del kernel - parte2
Parte IV
Informazioni aggiuntive
  1. Programmi utili
  2. Bibliografia

I precedenti capitoli hanno mostrato come scaricare e compilare il kernel. Ora che si ha un file eseguibile -- con tutti i moduli compilati -- è ora di installare il kernel e provare a fare il boot. In questo capitolo, a differenza dei precedenti, tutti i comandi necessitano di essere eseguiti come utente root. Questo può essere fatto anteponendo ad ogni comando sudo, usando il comando su per diventare root, oppure accedendo come root.

Per vedere se si ha sudo installato e gli appropriati diritti di accesso, lanciate: 

$ sudo ls ~/linux/linux-2.6.17.11/Makefile
Password:
Makefile

Inserite la vostra password personale al prompt di password, o la password dell'amministratore di sistema (root). La scelta dipende da come il comando di sudo è stato impostato. Se non ci sono problemi, e si vede una riga che contiene: 

Makefile

allora potete passare alla prossima sezione.

Se sudo non è installato o non si hanno i diritti appropriati, si provi ad usare il comando su: 

$ su
Password:
# exit
exit
$

Al prompt della password, inserite la password dell'amministratore di sistema (root). Quando su accetta con successo la password, si è trasferiti ad eseguire ogni cosa con i pieni privilegi di root. State molto attenti mentre siete root, e fate solo il minimo necessario; dopodiché uscite dal programma per tornare con il vostro utente normale.

Usare uno script di installazione di una distribuzione

Quasi tutte le distribuzioni hanno uno script chiamato installkernel che può essere usato dal sistema di creazione del kernel per installarne uno pronto automaticamente nel giusto posto e per modificare il bootloader così che nulla di più debba essere fatto dallo sviluppatore*.

caption

Le distribuzioni offrono installkernel solitamente in un pacchetto chiamato mkinitrd, provate ad installare questo pacchetto se non trovate lo script sulla vostra macchina.

Se avete compilato qualsiasi modulo e volete usare questo metodo per installare un kernel, inserite: 

# make modules_install

Questo installerà tutti i moduli che avete compilato e li metterà nelle appropriate locazioni del filesystem per farli trovare correttamente dal nuovo kernel. I moduli sono posti in /lib/modules/kernel_version, dove per kernel_version si intende la versione del nuovo kernel che avete appena compilato.

Dopo che i moduli sono stati installati con successo, l'immagine principale del kernel deve essere installata: 

# make install

Ciò farà partire il seguente processo:

  1. Il sistema di compilazione del kernel verificherà che il kernel sia stato correttamente compilato.
  2. Il sistema di compilazione copierà la parte statica nella directory /boot e rinominerà l'eseguibile sulla base della versione del kernel.
  3. Qualsiasi immagine di ramdisk iniziale necessaria verrà creata automaticamente, usando i moduli che sono appena stati installati durante la fase di modules_install.
  4. Al programma di bootloader verrà correttamente notificato che un nuovo kernel è presente, e verrà aggiunto nel giusto menu così che l'utente possa selezionarlo la prossima volta che la macchina verrà avviata.
  5. Dopo questo ha finito, il kernel è installato con successo, si può tranquillamente riavviare e provare la nuova immagine di kernel. Notare che questa installazione non sovrascrive nessuna vecchia immagine dei kernel, così se c'è un problema con la vostra nuova immagine del kernel, il vecchio kernel potrà essere selezionato al tempo d'avvio (boot time).

Nota (*): eccezioni da riportare a questa regola sono Gentoo e altre distribuzioni tipo "from scratch", le quali si aspettano che l'utente sappia come installare i kernel da solo. Questi tipi di distribuzioni includono la documentazione su come installare un nuovo kernel, si consulti quest'ultima per l'esatto metodo richiesto.

Installazione manuale

Se la distribuzione non è provvista del comando installkernel, o si desidera semplicemente fare il lavoro a mano per capire i passi che servono, eccoli qua:

I moduli devono essere installati: 

# make modules_install

L'immagine statica del kernel deve essere copiata nella directory /boot. Per un kernel basato su piattaforma i386, fare: 

  
# make kernelversion 
2.6.17.11

Notare che la versione del kernel probabilmente sarà differente da quella del vostro. Usate questo valore al posto del testo KERNEL_VERSION nei seguenti passaggi: 

# cp arch/i386/boot/bzImage /boot/bzImage-KERNEL_VERSION
# cp System.map /boot/System.map-KERNEL_VERSION

Modificare il bootloader in modo che conosca il nuovo kernel. Questo implica modificare il file di configurazione per il bootloader che si usa, è spiegato più avanti in "Modificare il bootloader per il nuovo kernel" in GRUB e LILO.

Se il processo di avvio non funziona, solitamente è perché una immagine iniziale di ramdisk (initial ramdisk) è necessaria. Per crearla correttamente, si usino i passi all'inizio di questo capitolo per installare un kernel automaticamente, poiché lo script di installazione della distribuzione sa come creare adeguatamente il ramdisk usando gli script e gli strumenti necessari. Dato che ogni distribuzione fa questo in maniera differente, è oltre lo scopo di questo libro ricoprire tutti i differenti metodi di costruzione dell'immagine di ramdisk.

Qui c'è uno script comodo che può essere usato per installare un kernel automaticamente invece di dover digitare tutti i precedenti comandi ogni volta: 

#!/bin/sh
#
# installs a kernel
#
make modules_install

# find out what kernel version this is
for TAG in VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION ; do
  eval `sed -ne "/^$TAG/s/ //gp" Makefile`
done
SRC_RELEASE=$VERSION.$PATCHLEVEL.$SUBLEVEL$EXTRAVERSION

# figure out the architecture
ARCH=`grep "CONFIG_ARCH " include/linux/autoconf.h | cut -f 2 -d "\""`

# copy the kernel image
cp arch/$ARCH/boot/bzImage /boot/bzImage-"$SRC_RELEASE"

# copy the System.map file
cp System.map /boot/System.map-"$SRC_RELEASE"

echo "Installed $SRC_RELEASE for $ARCH"

Modificare il bootloader per il nuovo kernel

Esistono due bootloader comuni per i kernel Linux: GRUB e LILO. GRUB è quello maggiormente usato nelle distribuzioni moderne, e fa alcune cose un po' più facilmente di LILO, ma LILO è ancora utilizzato. Li vedremo entrambi in questa sezione.

Per determinare quale bootloader il vostro sistema usa, guardate nella directory /boot/. Se esiste una sottodirectory grub: 

$ ls -F /boot | grep grub
grub/

allora si sta utilizzando GRUB come programma per fare il boot. Se questa directory non è presente, si guardi se è presente il file /etc/lilo.conf: 

$ ls /etc/lilo.conf
/etc/lilo.conf

se è presente, state usando LILO come programma per fare il boot.

I passi che implicano l'aggiunta del nuovo kernel a ognuno di questi programmi sono differenti, per cui si segua solo la sezione che corrisponde al programma che si sta usando.

GRUB

Per fare in modo che GRUB sappia che un nuovo kernel è presente, tutto ciò che dovete fare è modificare il file /boot/grub/menu.lst. Per i dettagli completi della struttura di questo file, e tutte le differenti opzioni disponibili, consultate le pagine di info di GRUB: 

$ info grub

Il metodo più facile per aggiungere una nuova voce kernel a /boot/grub/menu.lst è quello di copiare una voce già esistente. Per esempio, considerate il seguente menu.lst da un sistema Gentoo: 

timeout 300
default 0

splashimage=(hd0,0)/grub/splash.xpm.gz

title 2.6.16.11
  root (hd0,0)
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305

title 2.6.16
  root (hd0,0)
  kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305

La linea che comincia con la parola title definisce una nuova voce di kernel, in questo modo questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con la linea title, come: 

title 2.6.16.11
  root (hd0,0)
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305

Dopodiché aggiungete il blocco alla fine del file, e modificate il numero di versione con la nuova versione del nuovo kernel che si è appena installato. Il titolo non ha alcuna importanza, purché unico, ma visualizzato nel menu di boot, per cui si dovrebbe dargli qualcosa che abbia un significato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per tanto la copia finale del file assomiglierà a: 

timeout 300
default 0

splashimage=(hd0,0)/grub/splash.xpm.gz

title 2.6.16.11
  root (hd0,0)
  kernel /bzImage-2.6.16.11 root=/dev/sda2 vga=0x0305

title 2.6.16
  root (hd0,0)
  kernel /bzImage-2.6.16 root=/dev/sda2 vga=0x0305

title 2.6.17.11
  root (hd0,0)
  kernel /bzImage-2.6.17.11 root=/dev/sda2 vga=0x0305

Dopo che si è salvato il file, riavviate il sistema e assicuratevi che il titolo della nuova immagine del kernel sia presente nel menu di boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, e premete enter per avviare la nuova immagine.

LILO

Per fare in modo che LILO sappia che un nuovo kernel è presente, dovete modificare il file di configurazione /etc/lilo.conf ed eseguire il comando lilo per applicare le modifiche fatte al file di configurazione. Per i dettagli completi sulla struttura del file di configurazione di LILO, consultate la manpage di LILO: 

$ man lilo

Il modo più facile per aggiungere una nuova voce di kernel nel file /etc/lilo.conf è copiare una voce esistente. Per esempio, considerate il seguente file di configurazione di LILO di un sistema Gentoo: 

boot=/dev/hda
prompt
timeout=50
default=2.6.12

image=/boot/bzImage-2.6.15
  label=2.6.15
  read-only
  root=/dev/hda2

image=/boot/bzImage-2.6.12
  label=2.6.12
  read-only
  root=/dev/hda2

La linea che comincia con la parola image= definisce una nuova voce kernel, quindi questo file contiene due voci. Copiate semplicemente un blocco di linee che cominciano con image=, come: 

image=/boot/bzImage-2.6.15
  label=2.6.15
  read-only
  root=/dev/hda2

Aggiungete dopo il blocco alla fine del file, e modificate il numero di versione per contenere quella del nuovo kernel appena installato. La label non ha alcuna importanza, purché unica, ma è visualizzata nel menu di boot, per cui dovreste dargli qualcosa di sensato. Nel nostro esempio, abbiamo installato il kernel 2.6.17.11, per cui la copia finale del file sarà: 

boot=/dev/hda
prompt
timeout=50
default=2.6.12

image=/boot/bzImage-2.6.15
  label=2.6.15
  read-only
  root=/dev/hda2

image=/boot/bzImage-2.6.12
  label=2.6.12
  read-only
  root=/dev/hda2

image=/boot/bzImage-2.6.17
  label=2.6.17
  read-only
  root=/dev/hda2

Dopo aver salvato il file, lanciate il programma /sbin/lilo per salvare i cambiamenti del file di configurazione nella sezione di boot del disco: 

# /sbin/lilo

Ora il sistema può essere riavviato in sicurezza. La scelta del nuovo kernel si può vedere tra le scelte disponibili al momento del boot. Usate la freccia verso il basso per evidenziare la versione del nuovo kernel, premete Invio per avviare la nuova immagine.


This is an indipendent translation of the book Linux Kernel in a Nutshell by Greg Kroah-Hartman. This translation (like the original work) is available under the terms of Creative Commons Attribution-ShareAlike 2.5.


Capitolo originale

Estratto da "https://guide.debianizzati.org/index.php?title=LKN:_Installare_ed_Avviare_con_un_Kernel&oldid=41222"