[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]


20. Kernel Linux

Il kernel è il nocciolo del sistema operativo. I programmi utilizzano le funzioni fornite dal kernel, e in questa maniera sono sollevati dall'agire direttamente con la CPU.

Il kernel Linux è costituito normalmente da un file soltanto, il cui nome può essere `vmlinuz', oppure `zImage', `bzImage' e altri ancora, ma può comprendere anche moduli aggiuntivi per la gestione di componenti hardware specifici che devono poter essere attivati e disattivati durante il funzionamento del sistema.

Quando si fa riferimento a un kernel in cui tutte le funzionalità che servono sono incluse nel file principale, si parla di kernel monolitico, mentre quando parte di queste sono poste all'interno di moduli esterni, si parla di kernel modulare. Il kernel monolitico ha il vantaggio di avere tutto in un file, ma nello stesso modo è rigido e non permette di liberare risorse quando le unità periferiche gestite non servono. Il kernel modulare ha il vantaggio di poter disattivare e riattivare i moduli a seconda delle esigenze, in particolare quando moduli distinti gestiscono in modo diverso lo stesso tipo di unità periferica. Tuttavia, a causa della frammentazione in molti file, l'uso dei moduli può essere fonte di errori.

In generale, l'uso dei kernel modulari dovrebbe essere riservato agli utilizzatori che hanno già un'esperienza sufficiente nella gestione dei kernel monolitici. In ogni caso, ci possono essere situazioni in cui l'uso di un kernel modulare è praticamente indispensabile, per esempio quando un certo tipo di dispositivo fisico può essere gestito in vari modi differenti e conflittuali, ma si tratta di situazioni rare.

20.1 Ricompilazione del kernel

Le distribuzioni GNU/Linux tendono a fornire agli utilizzatori un kernel modulare per usi generali. Anche se questo si adatterà sicuramente alla maggior parte delle configurazioni, ci sono situazioni particolari dove è preferibile costruire un proprio kernel, monolitico o modulare che sia.

Per poter comprendere il procedimento di compilazione descritto in questo capitolo, occorre sapere come si compila e si installa un tipico programma distribuito in forma sorgente, come descritto nel capitolo 11.

20.1.1 Kernel monolitico

Il procedimento descritto in questa sezione serve per generare un kernel monolitico, cioè un kernel in un solo file.

Per poter procedere alla compilazione del kernel è necessario avere installato gli strumenti di sviluppo software, cioè il compilatore, e i sorgenti del kernel. In particolare, i sorgenti del kernel possono anche essere reperiti attraverso vari FTP. In tal caso si può fare una ricerca per i file che iniziano per `linux-x.y.z.tar.gz', dove x.y.z sono i numeri della versione.

Il numero di versione del kernel Linux è strutturato in tre livelli: x.y.z, dove il primo, x, rappresenta il valore più importante, mentre l'ultimo, z, rappresenta quello meno importante. Quello che conta, è porre attenzione al valore intermedio: y. Se si tratta di un numero pari, la versione si riferisce a un kernel ritenuto sufficientemente stabile, mentre un numero dispari rappresenta una versione destinata agli sviluppatori e non ritenuta sufficientemente sicura per l'utilizzo normale.

Se i sorgenti sono stati installati attraverso un disco (un CD-ROM) di una distribuzione, questi si troveranno al loro posto, altrimenti occorre provvedere a installarli manualmente. La posizione in cui devono trovarsi i sorgenti del kernel è la directory `/usr/src/linux/'. Se si utilizza un altra posizione è necessario utilizzare un collegamento simbolico che permetta di raggiungere i sorgenti nel modo prestabilito.

Occorre inoltre verificare che tre collegamenti simbolici contenuti nella directory `/usr/include/' siano corretti.

È evidente che il primo, `asm', dipende dal tipo di piattaforma hardware utilizzato.

Una volta installati i sorgenti del kernel, si può passare alla configurazione che precede la compilazione. Per questo, ci si posiziona nella directory dei sorgenti, e dopo aver letto il file `README', si può procedere come mostrato nel seguito.

cd /usr/src/linux

La directory corrente deve essere quella a partire dalla quale si diramano i sorgenti del kernel.

make mrproper

Serve a eliminare file e collegamenti vecchi che potrebbero interferire con una nuova compilazione.

make config

È l'operazione più delicata attraverso la quale si definiscono le caratteristiche e i componenti del kernel che si vuole ottenere. Ogni volta che si esegue questa operazione viene riutilizzato il file `.config' contenente la configurazione impostata precedentemente, e alla fine la nuova configurazione viene salvata nello stesso file. Di conseguenza, ripetendo il procedimento `make config', le scelte predefinite corrisponderanno a quelle effettuate precedentemente.

Il comando `make mrproper' elimina il file `.config', quindi si deve fare attenzione a non eseguire questo comando se non è questa l'intenzione.

Se si dispone di un kernel recente, in alternativa a `make config' che è un metodo piuttosto spartano di configurare il sistema, si possono utilizzare:

make menuconfig

un sistema di configurazione a menu basato su testo;

make xconfig

un sistema di configurazione a menu grafico per X.

+------------------------------- Main Menu -------------------------------+
|  Arrow keys navigate the menu.  <Enter> selects submenus --->.          |
|  Highlighted letters are hotkeys.  Pressing <Y> includes, <N> excludes, |
|  <M> modularizes features.  Press <Esc><Esc> to exit, <?> for Help.     |
|  Legend: [*] built-in  [ ] excluded  <M> module  < > module capable     |
| +---------------------------------------------------------------------+ |
| |      Code maturity level options  --->                              | |
| |      Processor type and features  --->                              | |
| |      Loadable module support  --->                                  | |
| |      General setup  --->                                            | |
| |      Plug and Play support  --->                                    | |
| |      Block devices  --->                                            | |
| |      Networking options  --->                                       | |
| |      SCSI support  --->                                             | |
| |      Network device support  --->                                   | |
| |      Amateur Radio support  --->                                    | |
| |      ISDN subsystem  --->                                           | |
| +------v(+)-----------------------------------------------------------+ |
+-------------------------------------------------------------------------+
|                    <Select>    < Exit >    < Help >                     |
+-------------------------------------------------------------------------+

Figura 20.1: Il menu principale della configurazione del kernel attraverso il comando `make menuconfig'.

36.jpg

Figura 20.2: Uno dei menu della configurazione del kernel attraverso il comando `make xconfig'.

Dopo la definizione della configurazione, si può passare alla compilazione del kernel relativo, utilizzando la sequenza di comandi seguente:

make dep ; make clean ; make zImage

Si tratta di tre operazioni che si possono avviare tranquillamente in questo modo perché non richiedono nessun tipo di interazione con l'utente. Al termine della compilazione, se questa ha avuto successo, il nuovo kernel si trova nella directory `/usr/src/linux/arch/i386/boot/' con il nome `zImage' (questo vale naturalmente nel caso si utilizzi l'architettura i386).

Se il kernel che si genera è troppo grande, potrebbe non funzionare l'istruzione `make zImage'. In tal caso si deve sostituire con `make bzImage' e alla fine si otterrà un file con quel nome, cioè `bzImage'. Si deve tenere in considerazione che anche in questo secondo caso esiste un limite massimo alla grandezza del kernel, per cui, nel caso questo venga superato, l'unica possibilità è data dall'utilizzo di moduli per le funzionalità che non sono indispensabili al caricamento del sistema.

Naturalmente, per fare in modo che il kernel possa essere utilizzato, questo andrà collocato dove è necessario che si trovi perché il sistema che si occupa del suo avvio possa trovarlo. Se si usa LILO occorrerà copiarlo nella directory radice o in `/boot/' e rinominarlo `vmlinuz' (come di consueto), oltre che ripetere l'installazione del sistema di caricamento LILO.

Una volta realizzato un kernel è necessario fare una prova per vedere se funziona. Il modo migliore (nel senso che è meno pericoloso) per verificarne il funzionamento è quello di farne una copia in un dischetto di avvio (ovvero un dischetto di boot). *1*

cp /usr/src/linux/arch/i386/boot/zImage /dev/fd0

Per utilizzare correttamente questo dischetto di avvio è molto probabile che si debba intervenire prima con il programma `rdev' ( 10.1.1).

20.1.2 Kernel modulare

Il procedimento per la creazione di un kernel modulare inizia nello stesso modo di quello monolitico e giunge alla creazione di un file che in più ha dei riferimenti a moduli esterni che vengono compilati a parte. Questi moduli, per poter essere gestiti correttamente, necessitano di programmi di utilità che si occupano della loro attivazione e disattivazione.

In questo caso, oltre ai sorgenti del kernel sono necessari i programmi per la gestione dei moduli. Questi si trovano normalmente in archivi il cui nome è organizzato in modo simile a quello dei sorgenti del kernel: `modules-x.y.z.tar.gz'. La struttura della versione rappresentata dai numeri x.y.z rispecchia lo stesso meccanismo utilizzato per i sorgenti del kernel, però non ne vengono prodotte altrettante versioni: si dovrà badare a utilizzare la versione più vicina a quella del kernel che si utilizza. Questo archivio si trova normalmente nella stessa directory del sito FTP dal quale si ottengono i sorgenti del kernel.

Anche i programmi contenuti nell'archivio `modules-x.y.z.tar.gz' sono in forma sorgente e per poter essere utilizzati devono essere compilati e installati.

Se si sta ricompilando il kernel attraverso i sorgenti della distribuzione GNU/Linux che si utilizza, è ragionevole supporre che questi programmi di gestione dei moduli siano già stati installati correttamente.

Per ottenere un kernel modulare, dopo la preparazione del file principale del kernel attraverso lo stesso procedimento visto nel caso di un kernel monolitico, si devono compilare i moduli.

make modules ; make modules_install

Quello che si ottiene sono una serie di file oggetto, il cui nome ha un'estensione `.o', raggruppati ordinatamente all'interno di directory discendenti da `/lib/modules/x.y.z/', dove x.y.z rappresenta il numero della versione dei sorgenti del kernel. La posizione di questi file non deve essere cambiata.

20.2 Elementi della configurazione

Gli elementi richiesti per la configurazione del kernel prima della sua compilazione, dipendono molto dalla versione che si possiede. In particolare, può capitare che alcune voci vengano spostate da una versione all'altra del kernel.

Nelle sezioni seguenti è riportata la descrizione delle opzioni più importanti dei kernel più recenti. Chi non dovesse trovare nel proprio kernel delle opzioni indicate qui, non dovrebbe preoccuparsene.

Code maturity level options
Processor type and features
Loadable module support
General setup
Plug and Play support
Block devices
Networking options
SCSI support
Network device support
Amateur Radio support
IrDA subsystem support
ISDN subsystem
Old CD-ROM drivers (not for SCSI or IDE/ATAPI drives)
Character devices
Filesystems
Console devices
Sound
Kernel hacking

Durante la descrizione che viene fatta nelle sezioni seguenti, viene indicata una possibile configurazione di un kernel adatto alle situazioni più comuni. In particolare, si immagina di disporre di:

A fianco di alcune opzioni di configurazione appare una lettera tra parentesi quadre: si tratta della proposta di configurazione. In particolare:

20.2.1 Code maturity level options

Questa sezione della procedura di configurazione si riferisce al livello di dettaglio a cui si è interessati, per quanto riguarda le opzioni di configurazione che possono essere richieste.

20.2.2 Processor type and features

Questa sezione serve a definire il tipo di microprocessore utilizzato. Nelle versioni del kernel meno recenti, queste indicazioni appartenevano alla sezione della configurazione generale.

20.2.3 Loadable module support

Questa sezione della procedura di configurazione permette di attivare il sistema di gestione dei moduli. I moduli sono blocchetti di kernel precompilati che possono essere attivati e disattivati durante il funzionamento del sistema. Solo alcune parti del kernel possono essere gestite in forma di modulo.

Conviene riservare l'utilizzo dei moduli alle situazioni in cui ciò è indispensabile o almeno di sicura utilità.

20.2.4 General setup

Questa sezione raccoglie una serie di opzioni di importanza generale, che non hanno trovato una collocazione specifica in un'altra posizione della procedura di configurazione. Mano a mano che le funzionalità del kernel Linux si estendono, aumentano le sezioni della configurazione, e di conseguenza capita che vi vengano spostate lì alcune di queste opzioni.

20.2.5 Plug and Play support

La gestione del Plug & Play permette al kernel di configurare automaticamente alcuni dispositivi che aderiscono a queste specifiche.

20.2.6 Block devices

Un dispositivo a blocchi è quello che utilizza una comunicazione a blocchi di byte di dimensione fissa, e si contrappone al dispositivo a caratteri con cui la comunicazione avviene byte per byte. Il dispositivo a blocchi tipico è un'unità a disco.

20.2.7 Networking options

La configurazione delle funzionalità di rete è importante anche se il proprio elaboratore è isolato. Quando è attiva la gestione della rete, il kernel fornisce implicitamente le funzionalità di inoltro dei pacchetti, consentendo in pratica il funzionamento come router. Tuttavia, l'attivazione di ciò dipende dall'inclusione della gestione del filesystem `/proc/' ( 20.2.15) e dell'interfaccia `sysctl' ( 20.2.4). Inoltre, durante il funzionamento del sistema è necessario attivare espressamente l'inoltro attraverso un comando simile a quello seguente:

echo '1' > /proc/sys/net/ipv4/ip_forward

20.2.8 SCSI support

Questa sezione riguarda la gestione del kernel delle unità SCSI.

20.2.9 Network device support

Questa sezione riguarda la definizione delle interfacce di rete che si utilizzano.

20.2.10 Amateur radio support

Questa sezione permette di configurare il kernel in modo da gestire le funzionalità legate alla comunicazione via radio (amatoriali).

20.2.11 IrDA subsystem support

20.2.12 ISDN subsystem

Questa sezione permette di definire e configurare l'utilizzo di dispositivi ISDN.

20.2.13 Old CD-ROM drivers (not for SCSI or IDE/ATAPI drives)

Se si dispone di un lettore CD-ROM diverso dagli standard SCSI o IDE/ATAPI, se ne deve selezionare il modello esatto.

20.2.14 Character devices

Un dispositivo a caratteri è quello che utilizza una comunicazione byte per byte e si contrappone a quello a blocchi con cui la comunicazione avviene attraverso l'uso di blocchi di byte di dimensione fissa.

20.2.15 Filesystems

Attraverso questa sezione si definiscono i tipi di filesystem che si vogliono gestire. In particolare, anche i filesystem virtuali, come `/proc/' e `/dev/pty/', vengono definiti qui.

20.2.16 Console drivers

Questa sezione permette di definire le caratteristiche della console.

20.2.17 Sound

20.2.18 Kernel hacking

Questa parte della configurazione è strettamente riservata agli esperti nella gestione del kernel e in generale serve per attivare un sistema di registrazione del comportamento del kernel stesso, allo scopo di ottenerne la sua ottimizzazione.

20.3 PLIP e stampa

La gestione della stampa su porta parallela e l'utilizzo di una connessione PLIP non sono più cose conflittuali nei kernel recenti.

In passato, per poter creare un kernel adatto alla gestione della porta parallela sia per la stampa che per un collegamento PLIP, occorreva attivare la gestione dei moduli ( 20.2.3) e indicare che il supporto al PLIP ( 20.2.9) e alla stampante parallela ( 20.2.14) avvengano attraverso moduli.

Il capitolo 87 descrive anche l'utilizzo di questo tipo di connessione.

---------------------------

Appunti Linux 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.it


1.) È bene ricordare che non si tratta di una copia nel senso normale del termine, perché in questo caso, cioè quello dell'esempio, il dischetto non contiene alcun filesystem. Di conseguenza, è inutile tentare poi di montare un dischetto del genere.

2.) Volendo seguire l'esempio iniziale, occorre selezionare il tipo NE2000.


[inizio] [indice generale] [precedente] [successivo] [indice analitico] [contributi]