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


241. nanoLinux II

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.

241.1 Lavoro di cesello

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 fatidica di 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.

241.1.1 Scegliere la fonte

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 le cose ulteriormente.

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

241.1.2 Installare e cancellare il superfluo

Dopo aver installato il minimo indispensabile, si procede con la cancellazione di ciò che non è assolutamente necessario, come per esempio la documentazione. Il vero problema sono le librerie: bisogna conservare fino all'ultimo quelle contenute in `/lib/*', e solo dopo che è stato deciso quale insieme di programmi si vuole mantenere, si potranno eliminare le librerie superflue.

Ci sono due librerie essenziali:

Se si utilizza solo uno dei due formati di programmi binari, basta la libreria dinamica relativa.

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 (di solito sono collegamenti simbolici) 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', come mostrato nell'esempio seguente:

ldconfig -r /mnt/prove

241.1.3 Revisione della procedura di inizializzazione del sistema

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'obiettivo 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.

241.1.4 Preparazione di un file-immagine

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.

241.1.5 Preparazione del dischetto

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 è pronto.

241.1.6 Kernel

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:

  1. Viene copiato nel dispositivo del dischetto.

    dd if=zImage of=/dev/fd0

  2. Il filesystem principale si troverà nel dischetto posto nella prima unità (anche se si tratta di un'immagine compressa).

    rdev /dev/fd0 /dev/fd0

  3. Il filesystem principale viene aperto inizialmente in lettura e scrittura: trattandosi di un disco RAM non è possibile fare altrimenti.

    rdev -R /dev/fd0 0

  4. L'immagine contenente il filesystem principale si trova in un dischetto separato, e lì si trova a partire dalla posizione iniziale dello stesso: lo scostamento è zero; si vuole l'immagine del filesystem principale sia caricata in un disco RAM; si vuole un preavviso per sapere quando si può togliere il dischetto del kernel per inserire il dischetto successivo.

    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.

241.1.7 Ultime considerazioni

Se si è fortunati, la coppia di dischetti è 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, benché ciò sia falso.

/dev/fd0         /        ext2     defaults      1   1

241.2 Dischi più grandi

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, relativamente, arrivare a una configurazione inferiore ai 20 Mbyte.

241.3 Provare nanoLinux

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 filesystem principale, e l'ultimo per i file aggiuntivi che non potevano essere contenuti nell'immagine compressa.

241.3.1 Reperire nanoLinux

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 del filesystem principale, seguita da una serie di file aggiuntivi che non potevano essere contenuti nell'altro dischetto. I nomi dovrebbero essere strutturati nel modo seguente:

  1. `nLinux-II.boot'

  2. `nLinux-II.root1.gz'

  3. `nLinux-II.root2.tar.gz'

I file vanno copiati così come sono nei dischetti, senza decomprimerli.

241.3.2 Preparazione dei dischetti

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 gli altri dischetti.

dd if=nLinux-II.root1.gz of=/dev/fd0

dd if=nLinux-II.root2.tar.gz of=/dev/fd0

241.3.3 Avvio di nanoLinux

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 quello successivo (`*.root1.*') 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 dell'ultimo dischetto.

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 identificazione per l'accesso.

(none) login:

Si può usare solo l'utente `root' e la password è quella specificata in precedenza, all'inizio della procedura di avvio.

root[Invio]

241.3.4 NFS

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

241.3.5 SMB

nanoLinux contiene anche il necessario per collegarsi a un servente 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 servente SMB, si deve utilizzare `smbmount'. Per esempio, se il servente `\\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

241.3.6 Spegnimento

La conclusione avviene nel modo solito.

shutdown -h now

241.4 Organizzazione di nanoLinux

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 servente NFS, un servente Rlogin/Rsh, e un servente 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 servente 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 dischetto contenente il filesystem (`*.root1.'), e copiandovi dentro il contenuto della seconda immagine (che in pratica è solo un file tar+gzip).

mount -o loop -t ext2 nLinux-II.root1 <punto-di-innesto>

cd <punto-di-innesto> ; tar xzvf nLinux-II.root2.tar.gz

241.4.1 Struttura

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

241.4.2 Procedura di inizializzazione del sistema

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.

241.4.3 Configurazione della rete

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

Tabella 241.1: Configurazione preimpostata della rete all'interno di nanoLinux.

241.4.4 Filesystem

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

241.4.5 Shell

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.

241.4.6 Attivazione e disattivazione dei servizi

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

241.5 Personalizzazione della procedura di inizializzazione del sistema

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'obiettivo 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).

241.5.1 Utilizzo in una partizione normale

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 2000.04.12 --- Copyright © 1997-2000 Daniele Giacomini --  daniele @ pluto.linux.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 zero, e di conseguenza si avrebbe `/dev/lp0' o `plip0'.


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