[successivo] [precedente] [inizio] [fine] [indice generale] [licenze] [indice analitico] [tomo] [parte]

Capitolo 21.   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.

21.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 12.

21.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. (1)

È 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 menù basato su testo;

# make xconfig

un sistema di configurazione a menù 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 21.1. Il menù principale della configurazione del kernel attraverso il comando make menuconfig.

figure/kernel-xconfig

Figura 21.2. Uno dei menù 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).(2)

# 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).

21.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 servizio 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.

21.1.3   Compilazione del kernel in una distribuzione GNU/Linux Debian

La distribuzione GNU/Linux Debian mantiene una separazione netta tra i file di intestazione dei sorgenti del kernel e quelli delle librerie di sviluppo. In questo modo, non si deve più provvedere a sistemare i collegamenti simbolici nella directory /usr/include/, al massimo ci può essere la necessità di aggiornare le librerie di sviluppo.

Per il resto, la procedura per la compilazione del kernel e dei moduli potrebbe essere svolta nello stesso modo già descritto. Tuttavia, questa distribuzione mette a disposizione uno strumento accessorio, molto utile, per facilitare questa operazione, passando per la creazione di un pacchetto Debian vero e proprio. Il pacchetto in questione è denominato kernel-package e per questo scopo può essere usato direttamente senza bisogno di alcuna configurazione. È sufficiente procedere nel modo seguente:

  1. cd  directory_iniziale_dei_sorgenti 

    ci si sposta nella directory iniziale dei sorgenti del kernel;

  2. make  {config|menuconfig|xconfig}

    si procede con la configurazione del kernel che si vuole ottenere;

  3. make-kpkg clean

    ci si prepara alla compilazione;

  4. make-kpkg --revision= versione  kernel_image

    si esegue la compilazione generando l'archivio Debian corrispondente, nella directory precedente.

L'esempio seguente si riferisce alla compilazione di un kernel 2.2.15 (compresi i moduli eventuali) collocato nella directory /usr/src/linux-2.2.15.(3)

# cd /usr/src/linux-2.2.15

# make-kpkg clean

# make-kpkg --revision=custom.1.0 kernel_image

Si può osservare che la versione è stata definita dalla stringa custom.1.0. Questo è ciò che viene suggerito nella documentazione originale. In particolare, il numero «1.0» va incrementato ogni volta che si predispone una versione successiva.

Al termine si ottiene l'archivio kernel-image-2.2.15_custom.1.0_i386.deb, collocato nella directory precedente a quella dei sorgenti da cui è stato ottenuto; per installarlo basta procedere come segue:

# dpkg -i ../kernel-image-2.2.15_custom.1.0_i386.deb

21.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:

21.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.

21.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.

21.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à.

21.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.

21.2.5   Plug and Play support

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

21.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.

21.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 file system /proc/ (21.2.15) e dell'interfaccia sysctl (21.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

21.2.8   SCSI support

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

21.2.9   Network device support

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

21.2.10   Amateur radio support

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

21.2.11   IrDA subsystem support

21.2.12   ISDN subsystem

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

21.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.

21.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.

21.2.15   Filesystems

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

21.2.16   Console drivers

Questa sezione permette di definire le caratteristiche della console.

21.2.17   Sound

21.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.

21.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 (21.2.3) e indicare che il supporto al PLIP (21.2.9) e alla stampante parallela (21.2.14) avvengano attraverso moduli.

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

Appunti di informatica libera 2001.01.30 --- Copyright © 2000-2001 Daniele Giacomini --  daniele @ swlibero.org

1) Questo problema dei collegamenti simbolici nella directory /usr/include/ riguarda solo alcune distribuzioni GNU/Linux. In particolare, nella distribuzione GNU/Linux Debian, le cose sono organizzate in modo da non dover toccare tale directory.

2) È 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 file system. Di conseguenza, è inutile tentare poi di montare un dischetto del genere.

3) Questa collocazione è volutamente differente da quella standard per la distribuzione GNU/Linux Debian, proprio per mostrare che ciò non influisce in questo contesto.

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

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome kernel_linux.html

[successivo] [precedente] [inizio] [fine] [indice generale] [licenze] [indice analitico] [tomo] [parte]