In questo capitolo si intende descrivere in che modo si può preparare un sistema GNU/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 GNU/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 ripristinare facilmente un sistema danneggiato.
A parte le considerazioni legate a una buona strategia per la sicurezza del proprio sistema, un piccolo sistema GNU/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 nell'introduzione.
|
nanoLinux II contiene anche Secure Shell, la cui licenza deve essere letta, dal momento che pone alcune restrizioni all'utilizzo in forma gratuita. Questa licenza si trova nell'appendice 200.1. |
Il modo più semplice per arrivare a una mini configurazione è quello di preparare una piccola partizione, installarvi GNU/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 GNU/Linux che si utilizza è sofisticata, attenta alla sicurezza e gradevole da utilizzare, tanto più difficile sarà questa operazione.
Se il risultato finale è di dimensioni ragionevolmente piccole (attualmente, la dimensione critica dovrebbe essere intorno agli 8 Mbyte), 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 1440 Kbyte, si può realizzare il proprio dischetto di emergenza, altrimenti occorre lasciare fuori una parte che non pregiudichi l'avvio, caricandola durante la fase di inizializzazione del sistema.
Un mini sistema GNU/Linux necessita di pochi attributi: semplicità e funzionalità. La sicurezza non conta, o almeno non dovrebbe. Quando si sceglie la fonte di GNU/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 questo è il caso di rivolgersi alla distribuzione Slackware: la più semplice e spartana, sia per il modo in cui sono realizzati i pacchetti che per la semplicità nella struttura degli script della procedura di inizializzazione del sistema (/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 quale insieme di programmi si vuole mantenere. A quel punto si potranno fare dei tentativi per scoprire quali non sono utilizzate.
Ci sono due librerie essenziali:
 |
la libreria dinamica per i binari compilati in formato a.out; |
|
la libreria dinamica per i binari compilati in formato ELF. |
Se si utilizza solo uno dei due formati di programmi binari, basta la libreria dinamica relativa.
Naturalmente, il nome effettivo di queste librerie è formato spesso dall'aggiunta dei numeri di versione. Quindi, ld.so potrebbe essere in realtà ld.so.1.7.14, o qualunque altra cosa. Per fare in modo che non ci siano problemi a raggiungere le librerie, occorre abbinare dei collegamenti (simbolici o meno) in modo da mantenere i riferimenti ai nomi normali.
Per conoscere di quali altre librerie si può avere bisogno, basta utilizzare il programma ldd. Per esempio:
$ ldd /bin/gzip[Invio]
libc.so.5 => /lib/libc.so.5.4.38 (0x40002000) |
Quando si interviene con i file di libreria, specialmente nel caso in cui questi vengano spostati o aggiunti, è necessario rigenerare il file /etc/ld.so.cache, attraverso il programma ldconfig.
Se si sta tentando di preparare un sistema su un disco che non sia il filesystem principale attuale, il file ld.so.cache potrebbe trovarsi ovunque, per esempio in /mnt/prove/etc/ld.so.cache. In una situazione del genere, si può utilizzare l'opzione -r
# ldconfig -r /mnt/prove
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 l'avvio e lo spegnimento corretto del sistema. L'attivazione di tutti i demoni superflui può essere eliminata.
|
Se l'obbiettivo finale è quello di realizzare un dischetto da caricare come disco RAM, non è possibile fare il controllo della partizione o del disco contenente il filesystem principale. |
Quando si pensa di avere raggiunto un risultato accettabile, se le dimensioni sono ragionevoli, si può preparare un file da utilizzare come immagine di un disco ipotetico. Si pone subito il problema della scelta del formato: Second-extended o Minix? Probabilmente il sistema appena sintetizzato avrà un numero molto elevato di file a causa dei dispositivi elencati all'interno di /dev/. Se non si eliminano quelli superflui, un'immagine Minix potrebbe non permettere l'inserimento di un numero di file così elevato. Nel caso del tipo Second-extended 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 4 Mbyte.
# dd if=/dev/zero of=~/miniroot.img bs=1k count=4k
Nell'esempio viene creato il file ~/miniroot.img, composto da caratteri <NUL>.
Si procede quindi con la creazione di un filesystem Second-extended.
# mke2fs -v -m 0 -i 1024 ~/miniroot.img
In questo modo si ottiene la creazione del filesystem; 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 sistema GNU/Linux creato, si deve eseguire il montaggio dell'immagine (sempre che il kernel permetta di farlo).
# mount -o loop -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 dischi RAM, altrimenti non si può avviare un'immagine compressa.
Alla fine deve essere preparato nel modo seguente:
Viene copiato nel dispositivo del dischetto.
# dd if=zImage of=/dev/fd0
Il filesystem principale si troverà nel dischetto posto nella prima unità (anche se si tratta di un'immagine compressa).
# rdev /dev/fd0 /dev/fd0
Il filesystem principale viene aperto inizialmente in lettura e scrittura: trattandosi di un disco RAM non è possibile fare altrimenti.
# rdev -R /dev/fd0 0
L'immagine del dischetto di root si trova in un dischetto separato e parte dalla posizione iniziale: lo scostamento è zero; si vuole che il dischetto root sia caricato in un disco RAM; si vuole un preavviso per sapere quando si può togliere il dischetto del kernel per inserire il dischetto root.
2^15 + 2^14 + 0 = 49152
# rdev -r /dev/fd0 49152
La dimensione predefinita del disco RAM è di 4 Mbyte. Se questo non basta, occorre informare il kernel in qualche modo. Se ci si trova in questa situazione, non è più tanto conveniente l'utilizzo di un kernel copiato in questo modo e configurato attraverso rdev; piuttosto diventa preferibile la preparazione di un dischetto con LILO che provvede all'avvio del kernel con tutte le opzioni necessarie. A questo proposito, si potrebbe usare una configurazione di /etc/lilo.conf simile a quanto descritto più avanti in riferimento a nanoLinux II.
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 ad ora e qualcuno potrebbe porsi il problema. Cosa deve contenere il file /etc/fstab sulla riga che descrive il filesystem principale? Si tratta di un disco RAM, e teoricamente vi si dovrebbe fare riferimento utilizzando il file di dispositivo /dev/ram. Se non dovesse funzionare così, si può 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 20 Mbyte.
nanoLinux richiede molta memoria RAM per poter funzionare, almeno 20 Mbyte. Per poterlo utilizzare occorrono tre dischetti: uno per contenere il kernel, un altro per l'immagine compressa del primo disco di root, e l'ultimo per i file aggiuntivi che non potevano essere contenuti nell'immagine compressa.
nanoLinux dovrebbe essere raggiungibile presso lo stesso nodo dal quale è stato ottenuto questo documento, oppure presso uno dei vari siti speculari FTP di Appunti Linux.
Si tratta di tre file: uno contenente l'immagine di un dischetto avviabile con un kernel molto semplice, in grado di gestire un disco RAM, una scheda Ethernet NE2000 e una connessione PLIP; gli altri due sono il vero nanoLinux, cioè un'immagine compressa da usare in un dischetto di root, seguita da una serie di file aggiuntivi che non potevano essere contenuti nell'altro dischetto. I nomi dovrebbero essere strutturati nel modo seguente:
nLinux-II.boot
nLinux-II.root1.gz
nLinux-II.root2.tar.gz
|
I file vanno copiati così come sono nei dischetti, senza decomprimerli. |
Si procede nel solito modo trasferendo prima l'immagine di boot.
# dd if=nLinux-II.boot of=/dev/fd0
Se invece di utilizzare questa immagine si preferisce un kernel realizzato personalmente, sarebbe meglio ricostruire un dischetto simile a quello che accompagna nanoLinux, di tipo Second-extended, contenente LILO. Infatti, è necessario specificare l'utilizzo di un disco RAM complessivo di 7 Mbyte. In pratica, è necessario il file /etc/lilo.conf seguente:
boot=/dev/fd0
#map=/boot/map
install=/boot/boot.b
prompt
#timeout=50
#message=/intro.txt
image=/vmlinuz
label=linux
root=/dev/fd0
append="ramdisk_start=0 load_ramdisk=1 prompt_ramdisk=1 ramdisk_size=7168"
read-write
|
Quindi si possono preparare i dischetti di root.
# dd if=nLinux-II.root1.gz of=/dev/fd0
# dd if=nLinux-II.root2.tar.gz of=/dev/fd0
Per avviare nanoLinux basta avviare l'elaboratore 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 il primo di root e quindi si può premere [Invio].
RAMDISK: Compressed image found at block 0 |
Se l'elaboratore è dotato di memoria sufficiente, l'immagine compressa contenuta nel dischetto viene caricata ed espansa, altrimenti si blocca il sistema.
Inizia quindi la procedura di inizializzazione del sistema, e viene richiesto quasi subito l'inserimento del secondo dischetto di root.
Inserire il secondo dischetto e premere un tasto. |
Successivamente viene richiesto di inserire la password per l'utente root. È necessario definire tale password, dal momento che nanoLinux mette in funzione alcuni servizi di rete, e nel tempo in cui viene usato potrebbe essere sfruttato per attaccare l'elaboratore su cui è in funzione.
Appare quindi la richiesta di un possibile utilizzo della rete. Conviene rispondere affermativamente, almeno nella maggior parte dei casi.
"Si vuole utilizzare un collegamento in rete? (s/n)" |
s[Invio]
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, probabilmente si dovrà utilizzare l'interfaccia plip1.
*1*
5[Invio]
Selezionare l'indirizzo. 1) 1.nano 4) 4.nano 7) 7.nano 2) 2.nano 5) 5.nano 8) 8.nano 3) 3.nano 6) 6.nano 9) 9.nano #? |
nanoLinux prevede già una rete e degli indirizzi abbinati a dei nomi, in modo da facilitare le operazioni di connessione con un altro elaboratore avviato con gli stessi dischetti. In questa fase, un indirizzo vale l'altro: viene scelto il primo.
1[Invio]
Dal momento che si tratta di una connessione PLIP e quindi punto-punto, è necessario indicare l'indirizzo dell'elaboratore all'altro capo. L'altro elaboratore verrà avviato nello stesso modo, utilizzando la stessa coppia di dischetti, ma facendo riferimento a indirizzi inversi.
Selezionare l'indirizzo dell'altro capo. 1) 1.nano 4) 4.nano 7) 7.nano 2) 2.nano 5) 5.nano 8) 8.nano 3) 3.nano 6) 6.nano 9) 9.nano #? |
2[Invio]
Al termine si ottiene un riassunto finale.
La configurazione selezionata è la seguente. Interfaccia plip1 Indirizzo 1.nano Indirizzo punto-punto 2.nano Si intende confermarla? (s/n) |
Se va tutto bene si conferma.
s[Invio]
La procedura di inizializzazione del sistema prosegue e al termine viene presentata la richiesta di login.
(none) login: |
Si può usare solo l'utente root e la password è quella specificata in precedenza, all'inizio della procedura di avvio.
root[Invio]
Continuando con lo stesso esempio iniziato nella sezione precedente, supponendo che anche l'elaboratore all'altro capo del cavo sia stato configurato correttamente (2.nano), le operazioni per il montaggio del filesystem di rete sono state semplificate opportunamente.
# mount /mnt/2
Quello appena visto è il modo più semplice per montare tutto il filesystem (a partire dalla radice) del nodo 2.nano nella directory /mnt/2/. Sono state previste tutte le directory necessarie, più altre aggiuntive (/mnt/a/ e /mnt/b/ per i dischetti Dos-VFAT, /mnt/cdrom/ per il CD-ROM, e /mnt/hd*/ per i dischi fissi).
nanoLinux contiene anche il necessario per collegarsi a un server SMB (Samba). sotto questo aspetto, se la cosa non scandalizza, potrebbe anche essere utilizzato per ripristinare un elaboratore su cui si utilizza MS-Windows 95/98, accedendo a un altro elaboratore del genere.
Per eseguire il montaggio di una directory condivisa da un server SMB, si deve utilizzare smbmount. Per esempio, se il server \\W5\ offre la condivisione di una directory identificata con il nome C e il suo indirizzo IP è 192.168.100.1, la si può montare nel modo seguente:
# smbmount //W5/C /mnt/extra1 -c micro -I 192.168.100.1
Parte delle opzioni di questo comando potrebbero essere ridondanti, ma conviene avere un esempio completo piuttosto che insufficiente. La directory condivisa viene montata a partire da /mnt/extra1/; l'elaboratore locale (quello avviato con il dischetto) verrà identificato con il nome micro ai fini del protocollo NetBIOS; l'elaboratore da raggiungere ha l'indirizzo IP 192.168.100.1 (questo deve essere specificato se si deve attraversare un router).
Operando come utente root, per smontare il filesystem di rete basta il normale umount.
# umount /mnt/extra1
La conclusione avviene nel modo solito.
# shutdown -h now
nanoLinux è il risultato delle operazioni di finitura descritte in precedenza, a partire dai binari di una distribuzione Slackware 3.5, e in parte da una distribuzione S.u.S.E. 5.2. Si tratta di un mini sistema di emergenza che comprende anche un server NFS, un server Rlogin/Rsh, e un server Secure Shell, in modo da permettere il trasferimento di dati tra elaboratori 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 questo occupa un filesystem Second-extended di 7 Mbyte, al quale si può accedere decomprimendo l'immagine del primo dischetto di root, e copiandovi dentro il contenuto della seconda immagine (che in pratica è solo un file tar+gzip).
mount |
cd <punto-di-innesto> ; tar xzvf nLinux-II.root2.tar.gz |
La struttura di questa specie di dischetto è molto semplice ed è schematizzabile nel modo seguente:
/
|-- bin
| |
| ` binari di uso generale
|
|-- dev
| |
| ` file di dispositivo
|
|-- etc
| |
| |-- rc.d
| | |
| | |-- init.d
| | | |
| | | ` script per il controllo dei servizi
| | |
| | ` script di inizializzazione
| |
| ` file di configurazione
|
|-- lib
| |
| ` file di libreria
|
|-- mnt
| |
| ` varie directory di innesto
|
|-- proc
|
|-- root
| |
| ` file di configurazione dell'utente root
|
|-- sbin --> bin
|
|-- script
| |
| ` script di utilità
|
|-- share
| |-- terminfo
| | |
| | ` informazioni sui tipi di terminale
| |
| ` file condivisi
|
|-- tmp
|
|-- usr
| |
| |-- bin --> ../bin
| |-- sbin --> bin
| |-- lib --> ../lib
| `-- share --> ../share
|
`-- var
|
` directory e file amministrativi vari
|
La prima cosa da fare per comprendere il funzionamento di un sistema particolare, è l'analisi della procedura di inizializzazione del sistema: /etc/inittab e gli script collegati.
|
Come si può osservare i livelli di esecuzione sono i soliti. Il livello normale è il numero tre, che permette la gestione dei demoni per l'attivazione dei servizi di rete. Si fa riferimento sempre solo a uno script: | |
|
Il file
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 elaboratori avviati con nanoLinux. È stata definita una rete secondo gli elementi riportati nella tabella 179.1.
| Elemento | Indirizzo IP | Nome completo | Abbreviazione |
| rete loopback | 127.0.0.0 | localdomain | |
| loopback | 127.0.0.1 | localhost.localdomain | localhost |
| rete esterna | 192.168.100.0 | nano | |
| elaboratore 1 | 192.168.100.1 | 1.nano | uno |
| elaboratore 2 | 192.168.100.2 | 2.nano | due |
| elaboratore 3 | 192.168.100.3 | 3.nano | tre |
| elaboratore 4 | 192.168.100.4 | 4.nano | quattro |
| elaboratore 5 | 192.168.100.5 | 5.nano | cinque |
| elaboratore 6 | 192.168.100.6 | 6.nano | sei |
| elaboratore 7 | 192.168.100.7 | 7.nano | sette |
| elaboratore 8 | 192.168.100.8 | 8.nano | otto |
| elaboratore 9 | 192.168.100.9 | 9.nano | nove |
|
Non si usa alcun server DNS e quindi la risoluzione dei nomi viene fatta esclusivamente utilizzando il file
| |
|
| |
|
|
Il file /etc/fstab è organizzato in modo tale da facilitare il montaggio dei filesystem di rete e di dischetti Dos eventuali.
Quindi, per esempio, per montare un dischetto Dos, è sufficiente il comando
# mount /mnt/a
e per montare la directory /mnt/ dell'elaboratore 5.nano basta il comando seguente:
# mount /mnt/5
|
| |
|
Il sistema consente l'utilizzo del proprio filesystem a partire dalla directory
|
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 sistemi minimi di protezione contro gli errori: la cancellazione, lo spostamento e la copia, non possono eliminare file senza una precisa conferma da parte dell'utente.
|
All'avvio, nanoLinux attiva inetd, il demone per i servizi RPC (da cui dipende NFS), quelli per il servizio NFS, e quello di Secure Shell. L'attivazione e la disattivazione di questi servizi può essere comandata agevolmente, utilizzando gli script collocati nella directory /etc/rc.d/init.d/. È sufficiente utilizzare gli argomenti start, stop e restart per ottenere rispettivamente l'avvio, la conclusione e il riavvio dei servizi relativi. Non sono state prese misure per controllare se un servizio è già attivo o meno.
A titolo di esempio, viene mostrato come disattivare il servizio NFS.
# /etc/rc.d/init.d/nfs stop
La personalizzazione di nanoLinux è possibile, a patto che poi venga considerato come un lavoro personale dell'autore delle modifiche e non più collegato con Appunti Linux o con l'autore di quest'ultimo.
La procedura di inizializzazione del sistema (init) è il primo punto su cui intervenire per una possibile personalizzazione. Oltre al file /etc/rc.d/rc, vengono anche utilizzati quelli seguenti.
/etc/rc.d/rc.config è uno script che serve a configurare la rete al volo prima che il sistema sia avviato completamente. Lo script, attraverso una serie di domande, prepara il file /etc/rc.d/rc.netconfig che viene letto successivamente dallo stesso /etc/rc.d/rc. Lo script /etc/rc.d/rc.config viene avviato all'interno della funzione OperazioniIniziali, mentre /etc/rc.d/rc.netconfig viene letto all'interno della funzione Net.
# OperazioniIniziali ... #-------------------------------------------------------------- # Obbliga l'utente a configurare il sistema. # Se si vuole usare una configurazione fissa nel file # /etc/rc.d/rc.netconfig, si può commentare. #-------------------------------------------------------------- /etc/rc.d/rc.config ... |
# Net ... #-------------------------------------------------------------- # Carica la configurazione contenuta in /etc/rc.d/rc.netconfig. #-------------------------------------------------------------- . /etc/rc.d/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 elaboratori attraverso il protocollo NFS e altri servizi. Quindi, nella funzione Server sono avviati per questo scopo vari demoni, attraverso gli script contenuti nella directory /etc/rc.d/init.d, che a loro volta accettano gli argomenti start (per l'avvio) e stop (per la conclusione).
Se, per un qualunque motivo si vuole trasferire nanoLinux in una partizione, nel file /etc/rc.d/rc occorre togliere, o commentare, il caricamento del contenuto del secondo dischetto di root, e attivare il sistema di controllo attraverso fsck. Si interviene nella funzione Sysinit.
# Sysinit ... #-------------------------------------------------------------- # Carica il secondo dischetto. # Per qualche strano motivo, sono necessari due read. #-------------------------------------------------------------- #cd / #echo "Inserire il secondo dischetto e premere un tasto." #read #read #tar xzf /dev/fd0 2> /dev/null #-------------------------------------------------------------- # Controlla l'integrità del filesystem principale. # 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 principale.
Probabilmente occorre aggiungere la directory /boot/ con il suo contenuto opportuno, in modo da poter utilizzare LILO per l'avvio.
Infine, il file /etc/lilo.conf andrà adattato opportunamente.
---------------------------
Appunti Linux 1999.07.12 --- Copyright © 1997-1999 Daniele Giacomini -- daniele @ evo.it
1.) 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.