In questo capitolo si intende descrivere in che modo si può preparare un microscopico sistema Linux di emergenza attraverso un esempio allegato a questa documentazione.
In questo periodo le unità di memorizzazione a disco, di medie o alte capacità, diventano sempre più accessibili e presto potrebbero addirittura sostituire completamente i nastri. In questa situazione, un piccolo sistema Linux potrebbe risiedere all'interno di dischi, insieme a delle copie di sicurezza, di modo che, con l'aiuto di un semplice dischetto di avvio, si possa facilmente ripristinare un sistema danneggiato.
A parte le considerazioni legate a una buona strategia per la sicurezza del proprio sistema, un piccolo sistema Linux può essere un buon banco di scuola per apprendere il funzionamento di componenti che altrimenti sfuggono nell'intrico di file di cui un sistema normale è composto.
Le condizioni alle quali è sottoposto l'utilizzo di nanoLinux sono riportate nel'introduzione, in particolare nella sezione `nanoLinux'.
Il modo più ``semplice'' per arrivare a una mini configurazione è quello di preparare una piccola partizione, installarvi Linux selezionando il minimo numero possibile di pacchetti, e quindi, piano piano, cancellando tutto quello che sembra inutile per i propri scopi. Naturalmente, non si può fare tutto in una volta, bisogna andare per tentativi: a un certo punto si potrebbe scoprire semplicemente che questo sistema non si avvia più...
Quanto più la distribuzione Linux che si utilizza è sofisticata e gradevole da utilizzare, tanto più difficile sarà questa operazione.
Se il risultato finale è di dimensioni ragionevolmente piccole (la dimensione critica dovrebbe essere intorno ai 4MB), si può decidere di preparare un file immagine. Quindi, con un po' di fortuna, se comprimendolo si riesce a stare al di sotto della dimensione di un dischetto da 1440KB, si può realizzare il proprio dischetto di emergenza.
Un mini sistema Linux necessita di pochi attributi: semplicità e funzionalità. La sicurezza non conta, o almeno non dovrebbe. Quando si sceglie la fonte di Linux da ``cannibalizzare'' per arrivare a una propria miniconfigurazione, non contano le misure di sicurezza che potrebbero invece servire a complicare ulteriormente le cose.
Per queste cose vale quindi la pena di rivolgersi alla distribuzione Slackware: la più semplice e spartana, sia per il modo in cui sono realizzati i pacchetti che per la semplicità della struttura degli script della procedura di inizializzazione (/etc/rc.d/*).
Vale la pena di ricordare che per installare un qualunque pacchetto Slackware basta decomprimere i pacchetti con tar ed eseguire lo script /install/doinst.sh.
Dopo aver installato il minimo indispensabile, si procede con la cancellazione di ciò che non è assolutamente necessario: la documentazione per esempio. Il vero problema sono le librerie: bisogna conservare fino all'ultimo quelle contenute in /lib/*, fino a quando non si è deciso il set i programmi da mantenere. A quel punto si potranno fare dei tentativi per scoprire quali non sono utilizzate.
Vale la pena di analizzare e modificare anche l'insieme di script che compongono la procedura di inizializzazione del sistema, quelli che solitamente si trovano sotto /etc/rc.d/. Da loro dipende per esempio un corretto spegnimento del sistema, oltre che l'attivazione delle console virtuali al momento dell'avvio. L'attivazione di tutti i daemon superflui può essere eliminata.
<!> Se l'obbiettivo finale è quello di realizzare un dischetto da caricare come ramdisk, non è possibile fare il controllo della partizione o del disco contenente il filesystem root.
Quando si pensa di aver raggiunto un risultato accettabile, se le dimensioni sono ragionevoli, si può preparare un file da utilizzare come immagine di un ipotetico disco. Si pone subito il problema della scelta del formato: Ext2 o Minix? Probabilmente il minisistema appena sintetizzato avrà un numero molto elevato di file a causa dei dispositivi elencati all'interno di /dev/. A meno di non eliminare quelli superflui, una immagine Minix potrebbe non permettere l'inserimento di un numero così elevato di file. Nel caso del tipo Ext2 occorre specificare una dimensione di inode molto piccola per permettere l'inserimento del massimo numero di voci possibili.
Si inizia con la creazione del file immagine, per esempio di 4MB.
# dd if=/dev/zero of=~/miniroot.img bs=1k count=4k
Nell'esempio viene creato il file ~/miniroot.img, composto da caratteri
Si procede quindi con la creazione di un filesystem Ext2.
# mke2fs -v -m 0 -i 1024 ~/miniroot.img
In questo modo si ottiene la creazione del filesystem e in particolare non viene riservata alcuna parte per l'utente root e la dimensione degli inode viene limitata a 1024 byte (il minimo possibile). Si ottiene quindi la possibilità di inserire un massimo teorico di 4096 file al suo interno.
Il programma fa notare che non si tratta di un disco, ma basta confermare e l'operazione procede ugualmente.
Un controllo può essere utile per verificare la situazione.
# e2fsck ~/miniroot.img
Infine, per potervi inserire il mini sistema Linux creato, si deve eseguire il mount dell'immagine (sempre che il kernel permetta di farlo).
# mount -o -t ext2 ~/miniroot.img /mnt
Nel file immagine non vanno copiati i file contenuti nella directory /boot/ e tanto meno il kernel.
Con un po' di fortuna, si riesce a comprimere il file immagine portandolo a una dimensione così piccola da poter essere contenuto in un dischetto. Prima di farlo, occorre che sia stato smontato.
# umount /mnt
# gzip -9 ~/miniroot.img
Il risultato sarà naturalmente il file ~/miniroot.img.gz. Se è andato tutto bene, si può trasferire in un dischetto.
# dd if=~/miniroot.img.gz of=/dev/fd0
Al termine il dischetto di root è pronto.
L'ultima cosa da fare è la preparazione del kernel. Nel capitolo precedente sono state descritte alcune caratteristiche importanti che questo dovrebbe avere. Vale la pena di ricordare che deve essere in grado di gestire i ramdisk, altrimenti non si può avviare un'immagine compressa.
Alla fine deve essere preparato nel modo seguente.
# dd if=zImage of=/dev/fd0
# rdev /dev/fd0 /dev/fd0
# rdev -R /dev/fd0 0
# rdev -r /dev/fd0 49152
Se si è fortunati, la coppia di dischetti boot e root è pronta per essere collaudata. Naturalmente, oltre alla fortuna occorre avere anche una buona quantità di memoria RAM.
C'è un particolare che è stato trascurato fino a ora e qualcuno potrebbe porsi il problema. Cosa deve contenere il file /etc/fstab sulla riga che descrive il filesystem root? Si tratta di un ramdisk, e teoricamente si dovrebbe farvi riferimento utilizzando il file di dispositivo /dev/ram. In pratica, così non funziona. Conviene lasciare il nome del dispositivo del dischetto, anche se ciò è falso.
/dev/fd0 / ext2 defaults 1 1
Se si hanno a disposizione dischi più grandi, non è necessario indaffararsi così tanto: con l'aiuto del programma di installazione della distribuzione che si ha a disposizione dovrebbe essere facile arrivare a una configurazione inferiore ai 20MB.
nanoLinux richiede molta memoria RAM per poter funzionare: servono almeno 8MB. Per poterlo utilizzare occorrono due dischetti: uno per contenere il kernel e l'altro per contenere l'immagine compressa del disco di root, cioè nanoLinux.
nanoLinux dovrebbe essere raggiungibile presso lo stesso computer host dal quale è stato ottenuto questo documento. Si tratta di due file: uno contenente un kernel molto semplice (non include la gestione di alcuna scheda SCSI), in grado di gestire ramdisk, una scheda Ethernet NE2000 e una connessione PLIP; l'altro è il vero nanoLinux, cioè una immagine compressa da usare in un dischetto di root.
I nomi dovrebbero essere strutturati nel modo seguente. Si tratta rispettivamente del nome del kernel e dell'immagine del disco root.
AppuntiLinux-<data-di-edizione>.nLkern.gz
AppuntiLinux-<data-di-edizione>.nLroot.gz
<!> Mentre il file del kernel deve essere decompresso per essere utilizzabile, l'immagine del disco root deve essere utilizzata così com'è.
Si procede nel solito modo trasferendo il prima il kernel.
dd if=<file-del-kernel> of=/dev/fd0
Se il kernel è stato realizzato personalmente, bisogna ricordare di assegnargli gli attributi corretti in modo da utilizzare un ramdisk.
# rdev /dev/fd0 /dev/fd0
# rdev -R /dev/fd0 0
# rdev -r /dev/fd0 49152
Quindi si può preparare il dischetto root.
dd if=<immagine-nanoLinux-compressa> of=/dev/fd0
Per avviare nanoLinux basta avviare il computer con il dischetto del kernel. Nel momento in cui il kernel presenta la richiesta
VFS: Insert root floppy disk to be loaded into ramdisk and press ENTER
si deve sostituire il dischetto con quello di root e quindi si può premere
RAMDISK: Compressed image found at block 0
Se il computer è dotato di memoria sufficiente, l'immagine compressa, contenuta nel dischetto, viene caricata ed espansa, altrimenti si blocca il sistema.
La fase successiva è quella in cui init prende il controllo e comincia l'esecuzione della procedura di inizializzazione.
Appare immediatamente un ``noioso'' messaggio di avvertimento sulle condizioni d'uso della raccolta.
ATTENZIONE
Questo dischetto è parte integrante del documento AppuntiLinux, all'interno del
quale viene descritto.
Si tratta di una minima raccolta di applicativi in grado di mettere in funzione
un sistema Linux elementare, utilizzabile come attrezzo multiuso o come punto
di partenza per uno studio personale.
L'AUTORE DI QUESTA RACCOLTA E GLI AUTORI DEI SINGOLI APPLICATIVI CHE LA
COMPONGONO NON SONO RESPONSABILI IN ALCUN MODO DELLE CONSEGUENZE DERIVATE DAL
SUO UTILIZZO, SIA CORRETTO CHE ERRONEO O FRAUDOLENTO.
L'UNICO RESPONSABILE DI QUALUNQUE CONSEGUENZA POSSA DERIVARE DALL'UTILIZZO DI
QUESTA RACCOLTA E' L'UTILIZZATORE.
Per accettare le condizioni sopra esposte si deve inserire la parola ACCETTO
seguita dalla pressione del tasto [Invio].
Per proseguire si deve quindi inserire proprio la parola ``ACCETTO'' usando solo lettere maiuscole.
ACCETTO
Appare quindi la richiesta di un possibile utilizzo della rete. Conviene rispondere affermativamente.
"Si vuole utilizzare un collegamento in rete? (s/n)"
s
Viene quindi richiesta l'indicazione del tipo di interfaccia di rete da utilizzare.
Selezionare l'interfaccia
1) eth0
2) eth1
3) eth2
4) plip0
5) plip1
6) plip2
#?
Supponendo di volere utilizzare una connessione PLIP sulla porta parallela si dovrà probabilmente utilizzare l'interfaccia plip1.
Dipende dal kernel l'assegnazione di questi nomi di interfaccia. Le nuove versioni 2.1.x e successive, potrebbero assegnare alla prima porta parallela l'indirizzo 0, e di conseguenza si avrebbe /dev/lp0 o plip0.
5
Selezionare l'indirizzo.
1) uno.nano 4) quattro.nano 7) sette.nano
2) due.nano 5) cinque.nano 8) otto.nano
3) tre.nano 6) sei.nano 9) nove.nano
#?
nanoLinux prevede già una rete e degli indirizzi abbinati a dei nomi, in modo da facilitare le operazioni di connessione con un altro computer avviato con gli stessi dischetti. In questa fase, un indirizzo vale l'altro: viene scelto il primo.
1
Dal momento che si tratta di una connessione PLIP e quindi Point-to-Point, è necessario indicare l'indirizzo del computer all'altro capo. L'altro computer verrà avviato nello stesso modo, utilizzando la stessa coppia di dischetti, ma facendo riferimento a indirizzi inversi.
Selezionare l'indirizzo dell'altro capo.
1) uno.nano 4) quattro.nano 7) sette.nano
2) due.nano 5) cinque.nano 8) otto.nano
3) tre.nano 6) sei.nano 9) nove.nano
#?
Ovviamente, deve trattarsi di un indirizzo diverso dal quello del computer locale.
2
Al termine si ottiene un riassunto finale.
La configurazione selezionata è la seguente.
Interfaccia plip1
Indirizzo uno.nano
Indirizzo Point-To-Point due.nano
Si intende confermarla? (s/n)
Se va tutto bene si conferma.
s
La procedura di inizializzazione prosegue e al termine viene presentata la richiesta di login.
nanoLinux
(none) login:
Si può usare root oppure ospite se si vuole intervenire come utente senza privilegi. Non ci sono password.
root
Continuando con lo stesso esempio iniziato nella sezione precedente, supponendo che anche il computer all'altro capo del cavo sia stato configurato correttamente (due.nano), le operazioni di mount del filesystem di rete sono state opportunamente semplificate.
# mount /mnt/due
Quello appena visto è il modo più semplice per montare tutto il filesystem (a partire dalla radice) del computer due.nano nella directory /mnt/due/. Sono state previste tutte le directory necessarie, più altre aggiuntive (da /mnt/a/ a /mnt/j/) per scopi vari.
La conclusione avviene nel modo solito.
# shutdown -h now
nanoLinux è il risultato delle operazioni di ``cesello'' descritte in precedenza, a partire dai binari di una distribuzione Slackware 3.1. Si tratta di un mini sistema di emergenza che comprende anche un server NFS, in modo da permettere il trasferimento di dati tra computer connessi in una piccola rete locale o attraverso un cavo parallelo (PLIP), senza bisogno di un server già esistente. Per motivi di comodità di utilizzo, la shell è bash.
Tutto è in un solo file immagine, al quale si può accedere dopo averlo decompresso nel modo già visto.
mount
-o loop -t ext2 <file-immagine-decompresso> <mount-point>
La struttura di questa specie di dischetto è molto semplice ed è schematizzabile nel modo seguente.
/
|-- bin
| |
| ` binari di uso generale
|
|-- dev
| |
| ` file di dispositivo
|
|-- etc
| |
| ` file di configurazione
|
|-- home
| `-- ospite
| |
| ` file di configurazione dell'utente generico
|-- lib
| |
| ` file di libreria indispensabili
|
|-- mnt
| |
| ` varie directory per il mount
|
|-- proc
|
|-- root
| |
| ` file di configurazione dell'utente root
|
|-- sbin
| |
| ` binari riservati all'utente root
|
|-- tmp
|
|-- usr
|
`-- var
|
` directory e file amministrativi vari
La prima cosa da fare per comprendere il funzionamento di un particolare sistema, è l'analisi della procedura di inizializzazione: /etc/inittab e gli script collegati.
# Livelli di esecuzione:
# 0 Arresto del sistema
# 1 Monoutente
# 2
# 3 Multiutente
# 4
# 5
# 6 Riavvio
# Livello di esecuzione predefinito.
id:3:initdefault:
# Inizializzazione del sistema - viene eseguito all'avvio.
si::sysinit:/etc/rc Sysinit
# Monoutente
l1:1:wait:/etc/rc 1
# Multiutente: Server di rete
l3:3:wait:/etc/rc 3
# [Ctrl+Alt+Canc].
ca::ctrlaltdel:/sbin/shutdown -t5 -rfn now
# Il livello di esecuzione 0 ferma il sistema.
l0:0:wait:/etc/rc 0
# Il livello di esecuzione 6 riavvia il sistema.
l6:6:wait:/etc/rc 6
# Attivazione della console.
c1:3:respawn:/sbin/agetty 38400 tty1 linux
c2:3:respawn:/sbin/agetty 38400 tty2 linux
c3:3:respawn:/sbin/agetty 38400 tty3 linux
c4:3:respawn:/sbin/agetty 38400 tty4 linux
c5:3:respawn:/sbin/agetty 38400 tty5 linux
c6:3:respawn:/sbin/agetty 38400 tty6 linux
Come si può osservare i livelli di esecuzione sono i soliti. Il livello normale è il tre che attiva la gestione dei daemon per la gestione del server NFS.
Si fa riferimento sempre solo a uno script: /etc/rc. A seconda dei casi, viene chiamato con un argomento differente.
Il file /etc/rc è organizzato in funzioni, in modo da permettere una organizzazione strutturata dello script. Quello che segue è lo schema che ne riassume il funzionamento.
#!/bin/bash
function Sysinit () {
...
/sbin/update &
...
OperazioniIniziali
}
function ControlloDisco () {
...
fsck ...
...
}
function OperazioniIniziali () {
...
}
function OperazioniFinali () {
...
}
function Net () {
ifconfig ...
route add ...
}
function Monoutente () {
...
}
function Multiutente () {
Net
Server
OperazioniFinali
}
function Server () {
rpc.portmap
rpc.mountd
rpc.nfsd
}
function Conclusione () {
sync
...
umount ...
}
function Halt () {
halt -f
}
function Reboot () {
reboot -f
}
#-----------------------------------------
case $1 in
Sysinit) Sysinit ;;
0) Conclusione ; Halt ;;
1) Monoutente ;;
3) Multiutente ;;
6) Conclusione ; Reboot ;;
Server) Server ;;
esac
Lo script inizia alla fine, dopo la dichiarazione di tutte le funzioni. A seconda dell'argomento ricevuto, esegue una catena differente di funzioni.
La rete è già stata configurata in modo da facilitare le connessioni ``volanti'' tra un piccolo gruppo di computer avviati con nanoLinux. È stata definita una rete secondo gli elementi riportati nella tabella (seguente).
Non si usa alcun server DNS e quindi la risoluzione dei nomi viene fatta esclusivamente utilizzando il file /etc/hosts.
order hosts
multi on
loopback 127.0.0.0
nano 192.168.100.0
127.0.0.1 localhost
192.168.100.1 uno.nano uno
192.168.100.2 due.nano due
192.168.100.3 tre.nano tre
192.168.100.4 quattro.nano quattro
192.168.100.5 cinque.nano cinque
192.168.100.6 sei.nano sei
192.168.100.7 sette.nano sette
192.168.100.8 otto.nano otto
192.168.100.9 nome.nano nove
Il file /etc/fstab è organizzato in modo tale da facilitare il mount dei filesystem di rete e di un eventuale dischetto aggiuntivo nella directory /usr/.
Quindi, per esempio, per montare un dischetto nella directory /usr/ è sufficiente il comando
# mount /usr
e per montare il filesystem root del computer cinque.nano basta il comando seguente.
# mount /mnt/cinque
#dispositivo mount tipo opzioni dump fsck
/dev/fd0 / ext2 defaults 1 1
proc /proc proc ignore
/dev/fd0 /usr ext2 noauto
uno.nano:/ /mnt/uno nfs noauto
due.nano:/ /mnt/due nfs noauto
tre.nano:/ /mnt/tre nfs noauto
quattro.nano:/ /mnt/quattro nfs noauto
cinque.nano:/ /mnt/cinque nfs noauto
sei.nano:/ /mnt/sei nfs noauto
sette.nano:/ /mnt/sette nfs noauto
otto.nano:/ /mnt/otto nfs noauto
nove.nano:/ /mnt/nove nfs noauto
Il sistema consente l'utilizzo del proprio filesystem a partire dalla radice, in lettura e scrittura a chiunque, specificando anche che l'utente root può mantenere i suoi privilegi. Purtroppo però il meccanismo non funziona e root continua a essere sostituito con nobody.
/ (rw,no_root_squash)
La shell utilizzata è bash, in modo da concedere all'utilizzatore un minimo di comodità. Il file dello storico dell'utente root e dell'utente generico sono in realtà diretti a /dev/null in modo da non utilizzare inutilmente lo spazio prezioso.
Attraverso la configurazione della shell si introducono dei minimi sistemi di sicurezza: la cancellazione, lo spostamento e la copia non possono eliminare file senza una precisa conferma da parte dell'utente.
PATH="/sbin:/usr/sbin:/usr/local/sbin:/bin:/usr/bin:/usr/local/bin:/var/script:."
TERM=linux
PS1='\u:\w\$ '
PS2='> '
ignoreeof=10
export PATH TERM PS1 PS2 ignoreeof
umask 022
alias cp='cp -i'
alias rm='rm -i'
alias mv='mv -i'
La personalizzazione di nanoLinux è possibile, a patto che poi venga considerato come un lavoro personale dell'autore delle modifiche e non più collegato con AppuntiLinux o con l'autore di quest'ultimo.
La procedura di inizializzazione (Init) è il primo punto su cui intervenire per una possibile personalizzazione. Oltre al file /etc/rc, vengono anche utilizzati i seguenti.
# Sysinit
...
#--------------------------------------------------------------
# Verifica la disponibilità dell'utente ad accettare le
# condizioni. Commentabile.
#--------------------------------------------------------------
#. /etc/rc.condizioni
...
# OperazioniIniziali
...
#--------------------------------------------------------------
# Obbliga l'utente a configurare il sistema.
# Se si vuole usare una configurazione fissa nel file
# /etc/rc.netconfig, si può commentare.
#--------------------------------------------------------------
/etc/rc.config
...
# Net
...
#--------------------------------------------------------------
# Carica la configurazione contenuta in /etc/rc.netconfig.
#--------------------------------------------------------------
. /etc/rc.netconfig
...
Per quanto riguarda la gestione della rete, vanno considerate due parti: la connessione alla rete stessa, attraverso l'indicazione degli indirizzi a cui si appartiene, e i servizi che si intendono concedere all'esterno.
La funzione Net è quella che si occupa di reperire e configurare gli indirizzi; la funzione Server è quella che avvia i servizi concessi all'esterno. L'obbiettivo di nanoLinux è quello di facilitare la connessione tra computer attraverso il protocollo NFS, offrendo questo servizio. Quindi, nella funzione Server sono avviati per questo scopo i daemon rpc.portmap, rpc.mountd e rpc.nfsd.
function Server () {
#--------------------------------------------------------------
# Questa funzione attiva alcuni daemon per offrire servizi di
# rete.
#--------------------------------------------------------------
# Avvia il portmapper.
#--------------------------------------------------------------
/sbin/rpc.portmap && echo "/sbin/rpc.portmap"
/sbin/rpc.mountd && echo "/sbin/rpc.mountd"
/sbin/rpc.nfsd && echo "/sbin/rpc.nfsd"
}
Se, per un qualunque motivo, si vuole trasferire nanoLinux in una partizione, occorre attivare nel file /etc/rc il sistema di controllo attraverso fsck. La modifica consiste nel togliere un commento nella funzione Sysinit.
# Sysinit
...
#--------------------------------------------------------------
# Controlla l'integrità del filesystem root.
# Commentare in caso di disco RAM!
#--------------------------------------------------------------
ControlloDisco
...
Oltre a questo, si dovrà modificare il file /etc/fstab in modo da indicare correttamente la partizione utilizzata per il filesystem root.
Probabilmente occorre aggiungere la directory /boot/ con il suo contenuto opportuno, in modo da poter utilizzare LILO per l'avvio.
Infine, il kernel andrà probabilmente riadattato, almeno per evitare che sia fatto un tentativo di caricamento in un ramdisk.
Trattandosi di un sistema da caricare su un ramdisk, è possibile estrarre anche il dischetto di root dopo l'avvio del sistema. In questo modo si può inserire un altro dischetto, con un regolare filesystem, montandolo opportunamente nella directory /usr/.
Un dischetto del genere potrebbe essere strutturato nel modo seguente.
|-- bin
| |
| ` binari addizionali di uso generale
|
|-- etc
|-- lib
| |
| ` file di libreria necessari per gli applicativi addizionali
|
|-- local
|
`-- sbin
|
` binari addizionali riservati all'utente root
Se si vogliono utilizzare programmi che utilizzano particolari funzionalità del terminale, come fa mc (Midnight Commander), oltre alle librerie relative, c'è bisogno dei file terminfo, in particolare quanto necessario per la gestione della console. Di seguito appare lo schema essenziale di quanto necessario per questo scopo.
|
|-- lib
| |
| |...
| |...
| |
| `-- terminfo
| |
| |...
| |...
| |-- c
| | `-- console
| |...
| |-- l
| | |-- linux
| | |-- linux-m
| | `-- linux-nic
| `...
1997.10.26 - Scritto da Daniele Giacomini daniele@calion.com (vedi copyright: Appunti Linux).