[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]

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

29.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 programma tipico distribuito in forma sorgente, come descritto nel capitolo 20.

29.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 presso vari siti che offrono l'accesso attraverso il protocollo 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 adatta 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 standard in cui devono trovarsi i sorgenti del kernel è la directory /usr/src/linux/. Se si utilizza un'altra posizione è necessario 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; quindi, 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, mentre 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 tale 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.

Figura 29.1. Il menù principale della configurazione del kernel attraverso il comando make menuconfig. 

.------------------------------- 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  --->                              | |
| |      Loadable module support  --->                                  | |
| |      Processor type and features  --->                              | |
| |      General setup  --->                                            | |
| |      Memory Technology Devices (MTD)  --->                          | |
| |      Parallel port support  --->                                    | |
| |      Plug and Play configuration  --->                              | |
| |      Block devices  --->                                            | |
| |      Multi-device support (RAID and LVM)  --->                      | |
| |      Networking options  --->                                       | |
| |      Telephony Support  --->                                        | |
| `------v(+)-----------------------------------------------------------' |
|-------------------------------------------------------------------------|
|                    <Select>    < Exit >    < Help >                     |
`-------------------------------------------------------------------------'

Figura 29.2. Uno dei menù della configurazione del kernel attraverso il comando make xconfig.

figure/a2-kernel-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, potrebbe essere necessario l'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 (parte vi). Di solito lo si copia nella directory radice o in /boot/, dandogli il nome vmlinuz (come di consueto), sistemando poi ciò che serve per il sistema di avvio che si utilizza.

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 (16.1.1).

29.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 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 prima di poterli utilizzare 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.

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

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

Le varie opzioni sono raggruppate in alcuni gruppi principali, che dovrebbero guidare intuitivamente nella configurazione prima della compilazione del kernel:

Nelle sezioni seguenti vengono descritte in parte solo alcuni di questi gruppi di configurazione, mostrando quale esempio che comunque non può esaurire il problema.

29.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. Se si è interessati a funzionalità relativamente nuove, conviene abilitare il dettaglio massimo nella selezione delle opzioni di configurazione.

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

Se si intende creare un kernel modulare, è evidente la necessità di attivare questa gestione all'interno della parte principale del kernel stesso.

[*] Enable loadable module support
[*]   Set version information on all module symbols
[*]   Kernel module loader

29.2.3   Processor type and features

Questa sezione serve a definire il tipo di microprocessore utilizzato. In generale, se si utilizza un'architettura di tipo ix86, la selezione del tipo di microprocessore 386 garantisce la creazione di un kernel compatibile nella maggior parte delle situazioni, a discapito però delle prestazioni.

Sempre nel caso di architettura di tipo ix86, è possibile abilitare l'emulazione per il coprocessore matematico (i487), che in alcuni elaboratori molto vecchi non era incluso. Di solito, l'inclusione del codice di emulazione non crea problemi di conflitti, perché viene individuata automaticamente la presenza dell'hardware relativo e l'emulazione non viene attivata se non quando necessario. In tal modo, includendo questa funzionalità si genera un kernel più compatibile.

(386) Processor family
< > Toshiba Laptop support (NEW)
< > /dev/cpu/microcode - Intel IA32 CPU microcode support (NEW)
< > /dev/cpu/*/msr - Model-specific register support (NEW)
< > /dev/cpu/*/cpuid - CPU information support (NEW)
(off) High Memory Support
[*] Math emulation
[*] MTRR (Memory Type Range Register) support
[ ] Symmetric multi-processing support
[ ] APIC and IO-APIC support on uniprocessors (NEW)

29.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, per cui capita che vi vengano spostate lì alcune di queste opzioni.

In particolare, all'interno di questa sezione dovrebbe essere possibile stabilire in modo preliminare:

[*] Networking support
[ ] SGI Visual Workstation support
[*] PCI support
(Any)   PCI access mode
[*] PCI device name database (NEW)
[ ] EISA support (NEW)
[ ] MCA support
[*] Support for hot-pluggable devices (NEW)
PCMCIA/CardBus support  --->
[*] System V IPC
[*] BSD Process Accounting
[*] Sysctl support
(ELF) Kernel core (/proc/kcore) format
<*> Kernel support for a.out binaries
<*> Kernel support for ELF binaries
<*> Kernel support for MISC binaries
[*] Power Management support (NEW)
[ ]   ACPI support (NEW)
< >   Advanced Power Management BIOS support

29.2.5   Parallel port support

La gestione della porta parallela non riguarda solo la stampa, dal momento che consente anche l'uso di altri tipi di unità periferiche. In questo gruppo di opzioni è possibile abilitare l'uso delle porte parallele, stabilendo eventualmente il grado di compatibilità di queste.

<*> Parallel port support
<*>   PC-style hardware
[ ]     Use FIFO/DMA if available (EXPERIMENTAL) (NEW)
[ ]     SuperIO chipset support (EXPERIMENTAL) (NEW)
[ ]     Support for PCMCIA management for PC-style ports (NEW)
[*]   Support foreign hardware
[ ]   IEEE 1284 transfer modes (NEW)

29.2.6   Plug and Play configuration

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

<*> Plug and Play support
<*>   ISA Plug and Play support (NEW)

29.2.7   Block devices

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

Merita attenzione particolare anche il dispositivo definito loopback,(5) che rappresenta in pratica un file contenente l'immagine di un disco, che viene letto come se fosse un disco o una partizione reale. Questa possibilità, tra le altre cose, consente di gestire direttamente i file che contengono la riproduzione esatta di dischetti, senza bisogno di trasferire questi file su dischetti reali.

Infine, è qui che si può abilitare e configurare la gestione dei dischi RAM, ovvero di dischi che vengono rappresentati nella memoria RAM.

<*> Normal PC floppy disk support
< > XT hard disk support
< > Parallel port IDE device support
< > Compaq SMART2 support
< > Compaq Smart Array 5xxx support (NEW)
< > Mylex DAC960/DAC1100 PCI RAID Controller support
<*> Loopback device support
<*> Network block device support
<*> RAM disk support
(8192)    Default RAM disk size (NEW)
[*]   Initial RAM disk (initrd) support

29.2.8   Multi-device support (RAID and LVM)

La gestione di più unità di memorizzazione in modo combinato richiede la selezione di un gruppo speciale di opzioni. Può trattarsi di dischi o partizioni ridondanti come forma di protezione dalle perdite di dati, oppure può essere un modo per fondere assieme più partizioni in una partizione logica più grande.

29.2.9   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/ (29.2.14) e dell'interfaccia sysctl (29.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

<*> Packet socket
[ ]   Packet socket: mmapped IO
[*] Kernel/User netlink socket
[*]   Routing messages
<*>   Netlink device emulation
[*] Network packet filtering (replaces ipchains)
[*] Socket Filtering
<*> Unix domain sockets
[*] TCP/IP networking
[*]   IP: multicasting
[*]   IP: advanced router
[*]     IP: policy routing
[*]       IP: fast network address translation
[*]     IP: equal cost multipath
[*]     IP: use TOS value as routing key
[*]     IP: verbose route monitoring
[*]     IP: large routing tables
[ ]   IP: kernel level autoconfiguration
<*>   IP: tunneling
<*>   IP: GRE tunnels over IP
[ ]     IP: broadcast GRE over IP
[ ]   IP: multicast routing
[ ]   IP: ARP daemon support (EXPERIMENTAL)
[ ]   IP: TCP Explicit Congestion Notification support
[*]   IP: TCP syncookie support (disabled per default)
  IP: Netfilter Configuration  --->
<*>   The IPv6 protocol (EXPERIMENTAL)
[*]     IPv6: enable EUI-64 token format
[*]       IPv6: disable provider based addresses
< >   Kernel httpd acceleration (EXPERIMENTAL)
[ ] Asynchronous Transfer Mode (ATM) (EXPERIMENTAL)
---
< > The IPX protocol
< > Appletalk protocol support
< > DECnet Support
< > 802.1d Ethernet Bridging
< > CCITT X.25 Packet Layer (EXPERIMENTAL)
< > LAPB Data Link Driver (EXPERIMENTAL)
[ ] 802.2 LLC (EXPERIMENTAL)
[ ] Frame Diverter (EXPERIMENTAL)
< > Acorn Econet/AUN protocols (EXPERIMENTAL)
< > WAN router
[ ] Fast switching (read help!)
[ ] Forwarding between high speed interfaces
QoS and/or fair queueing  --->

La gestione relativa a IPTables, dopo aver attivato la voce

[*] Network packet filtering (replaces ipchains)

diventa accessibile in un menù separato:

<*> Connection tracking (required for masq/NAT)
<*>   FTP protocol support
<*> Userspace queueing via NETLINK (EXPERIMENTAL)
<*> IP tables support (required for filtering/masq/NAT)
<*>   limit match support
<*>   MAC address match support
<*>   netfilter MARK match support
<*>   Multiple port match support
<*>   TOS match support
<*>   Connection state match support
<*>   Unclean match support (EXPERIMENTAL)
<*>   Owner match support (EXPERIMENTAL)
<*>   Packet filtering
<*>     REJECT target support
<*>     MIRROR target support (EXPERIMENTAL)
<*>   Full NAT
<*>     MASQUERADE target support
<*>     REDIRECT target support
<*>   Packet mangling
<*>     TOS target support
<*>     MARK target support
<*>   LOG target support

29.2.10   ATA/IDE/MFM/RLL support

La gestione di unità a blocchi tradizionali ed economiche, ATA/ATAPI, viene inserita in un menù apposito.

Eventualmente, si può arrivare a specificare dettagliatamente il tipo di integrato della propria interfaccia ATA, per sfruttare al massimo le sue caratteristiche, anche se questo non è indispensabile.(6)

<*> Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support
--- Please see Documentation/ide.txt for help/info on IDE drives
[ ]   Use old disk-only driver on primary interface
<*>   Include IDE/ATA-2 DISK support
[ ]     Use multi-mode by default
< >   PCMCIA IDE support
<*>   Include IDE/ATAPI CDROM support
< >   Include IDE/ATAPI TAPE support
<*>   Include IDE/ATAPI FLOPPY support
<*>   SCSI emulation support
--- IDE chipset support/bugfixes
[*]   CMD640 chipset bugfix/support
[ ]     CMD640 enhanced support
[ ]   ISA-PNP EIDE support
[*]   RZ1000 chipset bugfix/support
[*]   Generic PCI IDE chipset support
[*]     Sharing PCI IDE interrupts support
[*]     Generic PCI bus-master DMA support
[ ]     Boot off-board chipsets first support
[ ]     OPTi 82C621 chipset enhanced support (EXPERIMENTAL)
[ ]   Other IDE chipset support

29.2.11   SCSI support

Questa sezione riguarda la gestione del kernel delle unità SCSI. Le interfacce SCSI non hanno uno standard comune come avviene nel caso di quelle ATA e derivate, per cui è indispensabile includere il codice specifico per tutte le interfacce che si intendono utilizzare.

In certe situazioni può essere necessario abilitare la gestione della «gestione generica» SCSI. In particolare, questo serve nel caso si preveda l'uso di un masterizzatore SCSI.

<*> SCSI support
--- SCSI support type (disk, tape, CD-ROM)
<*>   SCSI disk support
(40) Maximum number of SCSI disks that can be loaded as modules
< >   SCSI tape support
< >   SCSI OnStream SC-x0 tape support
<*>   SCSI CD-ROM support
[ ]     Enable vendor-specific extensions (for SCSI CDROM)
(2) Maximum number of CDROM devices that can be loaded as modules
<*>   SCSI generic support
--- Some SCSI devices (e.g. CD jukebox) support multiple LUNs
[*]   Enable extra checks in new queueing code
[*]   Probe all LUNs on each SCSI device
[*]   Verbose SCSI error reporting (kernel size +=12K)
[*]   SCSI logging facility
SCSI low-level drivers  --->
PCMCIA SCSI adapter support  --->

29.2.12   Network device support

Questa sezione riguarda la definizione delle interfacce di rete che si utilizzano, includendo anche interfacce logiche, che non corrispondono a componenti fisici veri e propri, oltre che alcuni protocolli utilizzati come tunnel nell'ambito di hardware che di solito non viene usato per le reti (per esempio il PPP con le porte seriali e il PLIP con le porte parallele).

[*] Network device support
ARCnet devices  --->
<*> Dummy net driver support
< > Bonding driver support
< > EQL (serial line load balancing) support
<*> Universal TUN/TAP device driver support
< > Ethertap network tap (OBSOLETE)
< > General Instruments Surfboard 1000
Ethernet (10 or 100Mbit)  --->
Ethernet (1000 Mbit)  --->
[ ] FDDI driver support
[ ] HIPPI driver support (EXPERIMENTAL)
<*> PLIP (parallel port) support
<*> PPP (point-to-point protocol) support
[ ]   PPP multilink support (EXPERIMENTAL)
<*>   PPP support for async serial ports
<*>   PPP support for sync tty ports
<*>   PPP Deflate compression
<*>   PPP BSD-Compress compression
< >   PPP over Ethernet (EXPERIMENTAL)
<*> SLIP (serial line) support
[*]   CSLIP compressed headers
[*]   Keepalive and linefill
[*]   Six bit SLIP encapsulation
Wireless LAN (non-hamradio)  --->
Token Ring devices  --->
[ ] Fibre Channel driver support
< > Red Creek Hardware VPN (EXPERIMENTAL)
< > Traffic Shaper (EXPERIMENTAL)
Wan interfaces  --->
PCMCIA network device support  --->

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

Questo gruppo di opzioni serve a definire l'uso del terminale (che potrebbe anche essere escluso nel caso di kernel con funzioni specifiche), inteso come complesso di schermo e tastiera, delle porte seriali, delle porte parallele, dei mouse e altri componenti simili.

È importante sottolineare il fatto che non si deve definire esplicitamente l'uso di un mouse seriale, perché per questo è sufficiente configurare la porta seriale corrispondente, mentre nel caso di mouse differenti, occorre indicare espressamente di cosa si tratta.

In questo gruppo di opzioni appare anche un elenco di schede grafiche particolari.

[*] Virtual terminal
[*]   Support for console on virtual terminal
<*> Standard/generic (8250/16550 and compatible UARTs) serial support
[*]   Support for console on serial port
[ ] Extended dumb serial driver options
[ ] Non-standard serial port support
[*] Unix98 PTY support
(256) Maximum number of Unix98 PTYs in use (0-2048)
<*> Parallel printer support
[ ]   Support for console on line printer
< > Support for user-space parallel port device drivers
I2C support  --->
Mice  --->
Joysticks  --->
< > QIC-02 tape support
Watchdog Cards  --->
< > Intel i8x0 Random Number Generator support
<*> /dev/nvram support
< > Enhanced Real Time Clock Support
< > Double Talk PC internal speech card support
< > Siemens R3964 line discipline
< > Applicom intelligent fieldbus card support
Ftape, the floppy tape device driver  --->
< > /dev/agpgart (AGP Support)
[ ] Direct Rendering Manager (XFree86 DRI support)
PCMCIA character device support  --->

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

Il file system standard dei sistemi GNU/Linux è il tipo Second-extended, ovvero Ext2 o Ext3. La gestione di questo tipo di file system deve essere inclusa nel kernel, a meno che si stia cercando di produrre del codice specifico per un'applicazione particolare.

In questo gruppo di opzioni trovano posto anche quelle necessarie alla condivisione attraverso la rete, per esempio con il protocollo NFS.

È interessante osservare che è necessario specificare anche i sistemi di partizionamento dei dischi. In generale è indispensabile la gestione delle partizioni tipiche dei sistemi Dos.

Infine, è importante anche tenere in considerazione il tipo di codifica che si vuole poter utilizzare nell'ambito del file system. La codifica in questione riguarda il modo di rappresentare i nomi dei file, che potrebbe richiedere estensioni particolari. In generale viene abilitata la codifica ISO 8859-1, che è quella più frequente nel mondo occidentale.

[*] Quota support
<*> Kernel automounter support
<*> Kernel automounter version 4 support (also supports v3)
< > Reiserfs support
< > ADFS file system support
< > Amiga FFS file system support (EXPERIMENTAL)
< > Apple Macintosh file system support (EXPERIMENTAL)
< > BFS file system support (EXPERIMENTAL)
<*> DOS FAT fs support
<*>   MSDOS fs support
<*>     UMSDOS: Unix-like file system on top of standard MSDOS fs
<*>   VFAT (Windows-95) fs support
< > EFS file system support (read only) (EXPERIMENTAL)
< > Compressed ROM file system support
< > Simple RAM-based file system support
<*> ISO 9660 CDROM file system support
[*]   Microsoft Joliet CDROM extensions
<*> Minix fs support
< > NTFS file system support (read only)
< > OS/2 HPFS file system support
[*] /proc file system support
[ ] /dev file system support (EXPERIMENTAL)
[*] /dev/pts file system for Unix98 PTYs
< > QNX4 file system support (read only) (EXPERIMENTAL)
< > ROM file system support
<*> Second extended fs support
< > System V and Coherent file system support (read only)
< > UDF file system support (read only)
< > UFS file system support (read only)
Network File Systems  --->
Partition Types  --->
Native Language Support  --->

Quello che segue è il menù specifico per i file system di rete (come NFS):

<*> Coda file system support (advanced network fs)
< > InterMezzo file system support (experimental, replicating fs)
<*> NFS file system support
[*]   Provide NFSv3 client support
<*> NFS server support
[*]   Provide NFSv3 server support
<*> SMB file system support (to mount Windows shares etc.)
[ ]   Use a default NLS
< > NCP file system support (to mount NetWare volumes)

29.2.15   Console drivers

Questa sezione permette di definire le caratteristiche della console. In generale si tratta di affermare l'uso di una console VGA, cosa praticamente obbligatoria, salva la possibilità di compilare un kernel per un sistema senza console.

[*] VGA text console
[*] Video mode selection support
< > MDA text console (dual-headed) (EXPERIMENTAL)
Frame-buffer support  --->

29.2.16   Sound

Questo gruppo di opzioni consente di gestire le funzionalità audio, specificando l'uso di una scheda audio particolare. Un gruppo importante di schede audio è gestito da un modulo speciale, definito «OSS».

29.2.17   USB support

Questo gruppo di opzioni consente la gestione di adattatori USB e delle unità periferiche relative.

<*> Support for USB
[ ]   USB verbose debug messages
--- Miscellaneous USB options
[*]   Preliminary USB device filesystem
[ ]   Enforce USB bandwidth allocation (EXPERIMENTAL)
--- USB Controllers
<*>   UHCI (Intel PIIX4, VIA, ...) support
<*>   OHCI (Compaq, iMacs, OPTi, SiS, ALi, ...) support
--- USB Device Class drivers
< >   USB Audio support
< >   USB Bluetooth support (EXPERIMENTAL)
<*>   USB Mass Storage support
< >   USB Modem (CDC ACM) support
< >   USB Printer support
--- USB Human Interface Devices (HID)
---   Input core support is needed for USB HID
--- USB Imaging devices
< >   USB Kodak DC-2xx Camera support
< >   USB Mustek MDC800 Digital Camera support (EXPERIMENTAL)
<*>   USB Scanner support
< >   Microtek X6USB scanner support (EXPERIMENTAL)
--- USB Multimedia devices
< >   DABUSB driver
--- USB Network adaptors
< >   PLUSB Prolific USB-Network driver (EXPERIMENTAL)
< >   USB ADMtek Pegasus-based ethernet device support (EXPERIMENTAL)
< >   NetChip 1080-based USB Host-to-Host Link (EXPERIMENTAL)
--- USB port drivers
< >   USS720 parport driver
USB Serial Converter support  --->
--- USB misc drivers
< >   USB Diamond Rio500 support (EXPERIMENTAL)

29.3   Come fare per configurare correttamente il kernel che si vuole compilare

Il kernel Linux è molto dinamico e il suo sviluppo prende spesso delle strade imprevedibili. Questa vitalità è molto importante per il futuro del software libero; senza di essa non ci sarebbe modo di usare domani le nuove tecnologie che verranno proposte. In questo senso, diventa difficile dare delle indicazioni precise e durature sul modo corretto di configurare il kernel prima della compilazione.

L'unica documentazione sicura sotto questo aspetto è quella che si può consultare in modo contestuale quando si utilizza il comando make menuconfig, oppure make xconfig. Eventualmente, può essere utile sapere che le informazioni che si leggono lì sono contenute nel file Documentation/Configure.help (nell'ambito dei sorgenti). Segue un estratto di questo file:

Support for USB
CONFIG_USB
  Universal Serial Bus (USB) is a specification for a serial bus
  subsystem which offers higher speeds and more features than the
  traditional PC serial port. The bus supplies power to peripherals
  and allows for hot swapping. Up to 127 USB peripherals can be
  connected to a single USB port in a tree structure. The USB port is
  the root of the tree, the peripherals are the leaves and the inner
  nodes are special USB devices called hubs. Many newer PC's have USB
  ports and newer peripherals such as scanners, keyboards, mice,
  modems, and printers support the USB protocol and can be connected
  to the PC via those ports.

  Say Y here if your computer has a USB port and you want to use USB
  devices. You then need to say Y to at least one of "UHCI support" or
  "OHCI support" below (the type of interface that the USB hardware in
  your computer provides to the operating system) and then choose from
  among the drivers for USB peripherals. You may want to check out the
  information provided in Documentation/usb/ and especially the links
  given in Documentation/usb/usb-help.txt.

  This code is also available as a module ( = code which can be
  inserted in and removed from the running kernel whenever you want).
  The module will be called usbcore.o. If you want to compile it as a
  module, say M here and read Documentation/modules.txt.

Quando si parte da zero, è sufficiente accertarsi di eliminare il file .config, che comunque viene eliminato con il comando make mrproper. In questo modo, il programma che guida alla configurazione del kernel offre già le risposte più ovvie alle domande che fa. Naturalmente è sempre necessario leggere le prime volte il testo delle spiegazioni disponibili, fino a che si raggiunge una dimestichezza adeguata al tipo di esigenze che si hanno.

Come la documentazione interna suggerisce spesso, nella directory Documentation/ sono contenuti tanti file di testo contenenti spiegazioni particolareggiate rispetto a problemi specifici della configurazione. A questo punto dovrebbe essere evidente che non si può configurare e compilare un kernel se non si conosce minimamente la lingua inglese.

Questo tipo di lavoro passa poi necessariamente per una lunga serie di tentativi falliti (avendo cura di conservare i file .config, per poter ripartire almeno dall'ultima configurazione tentata). Tuttavia, il principiante non deve pensare di essersi messo involontariamente nei guai, perché queste difficoltà riguardano tutti, anche gli esperti, proprio perché la dinamicità nello sviluppo del kernel Linux porta continue novità.

Appunti di informatica libera 2003.01.01 --- Copyright © 2000-2003 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) La gestione di bus ISA è solitamente implicita.

5) Il termine loop device usato qui, non deve essere confuso con loopback device usato nella configurazione dei servizi di rete.

6) Salva la convenienza di includere in ogni caso il codice necessario ad aggirare i difetti gravi di alcuni integrati del genere.

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

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]