%--------------------------------------------------------------------
\chapter{Uso dei dischi e di altri mezzi di immagazzinamento}
%--------------------------------------------------------------------

        \begin{chapterquote}
	On a clear disk you can seek forever. \\
        \end{chapterquote}

% the following metas need too much work for the next version
%
%	\meta copying a directory/disk verbatim
%
%	\meta disaster recovery: program to scan for ext2 superblocks
%
%	\meta explain lost+found; how to fix a filesystem; what to do when
%	there is a bad block; identifying the file that has the bad block
%	
%	\meta chart that shows characteristics of various fs: max size,
%	max file size, usable as root, max name length, speed, support
%
%	\meta 
%	Recovering from a bad MBR or super block.
%	Manually remounting (ro->rw, rw->ro, when, why)
%	automounting
%	MD patches
%	Why does Linux read/write disk in background?
%	how to mount a dos disk so that everyone can access it?
%	supermount
%	ide disks map away bad sectors (until they're too many, then
%	use badblocks)
%	mounting: mountee root becomes mount point, e.g. permissions/ownership
%	linux has maximum of 15 partitions (not inherent in partition
%		scheme!)
%	max ext2 part size is 2TB, file 2 GB
%	ext2 fragmentation
%	list important device files for disks et al as a table

        \noindent
	Quando si installa o si aggiorna un sistema, bisogna lavorare molto sui dischi; bisogna creare filesystem sui dischi in modo da poterci memorizzare dei file, e riservare spazio per le varie parti del sistema.

	Questo capitolo spiega tutte queste attività iniziali. Di solito, una volta impostato il sistema, non dovrete rifare tutto il lavoro, tranne che per i floppy. Dovrete ritornare a questo capitolo per aggiungere un nuovo disco o per rifinire l'utilizzo di quelli che avete.

	I compiti di base nell'amministrazione dei dischi sono:
	%%
        \begin{itemize}
        \item
	La formattazione, che fa diverse cose per preparare il disco all'uso, come controllare se ci sono settori danneggiati (oggigiorno non è necessario formattare la maggior parte degli hard disk).

        \item
	Il partizionamento, se volete usare il disco per diverse attività che non dovrebbero interferire l'una con l'altra. Una ragione per ripartizionare il disco è se volete usare diversi sistemi operativi sullo stesso disco, un'altra è di tenere i file degli utenti separati dai file di sistema, cosa che semplifica i backup ed aiuta a proteggere i file di sistema.

        \item
	La creazione di un filesystem (di tipo adatto) su ciascun disco o partizione. I dischi non risultano a Linux finché non ci create un filesystem: a quel punto potete memorizzarci file, ed accedere a quelli presenti.

        \item
	Il montaggio di diversi filesystem per formare una singola struttura ad albero, sia automaticamente che manualmente, a seconda delle circostanze (dovete fare l'unmount manuale dei filesystem montati manualmente).

        \end{itemize}

	Il capitolo~\ref{chap:mem} contiene informazioni sulla memoria virtuale e sulla cache del disco, di cui dovete essere coscienti quando usate i dischi.

	Questo capitolo spiega cosa dovete sapere per quanto riguarda gli hard disk, i floppy, i CD-ROM e le unità nastro.

\section{Due tipi di dispositivi}

	UNIX, e quindi Linux, riconosce due tipi diversi di dispositivi: i dispositivi a blocchi ad accesso casuale (come i dischi) ed i dispositivi a carattere (come i nastri e le linee seriali), alcuni dei quali sono seriali, altri ad accesso casuale. Ogni dispositivo supportato viene rappresentato nel filesystem come un \defin{file di device}. Quando si legge o si scrive un file di device, i dati provengono o vanno al dispositivo che rappresenta. In questo modo non è necessario nessun programma speciale (e nessuna metodologia speciale per la programmazione delle applicazioni, come la cattura degli interrupt o il mandare richieste ad una porta seriale); ad esempio, per mandare un file alla stampante, basta dire
		%
		\begin{tscreen}
\verb|$| {\sl cat nomefile $>$ /dev/lp1} \\ 
\verb|$|
		\end{tscreen}
		%
	ed il contenuto del file viene stampato (il file deve, naturalmente, essere in una forma che venga riconosciuta dalla stampante). Comunque, dato che non è una buona idea avere diverse persone che inviano file usando cat contemporaneamente alla stampante, di solito si usa un programma speciale per farlo (di solito \cmd{lpr}). Un programma del genere si assicura che venga stampato solo un file alla volta, e manderà gli altri file in stampa in sequenza a mano a mano che la stampante finisce il precedente. Anche per la maggior parte degli altri dispositivi serve una cosa del genere; in effetti, in genere non ci si deve preoccupare per niente di questo tipo di file.

	Dato che i dispositivi appaiono nel filesystem (nella directory \fn{/dev}), è facile vedere quali file di device esistono usando \cmd{ls} o un altro comando adatto. Nell'output di \cmd{ls -l}, la prima colonna contiene il tipo di file ed i suoi permessi. Ad esempio, guardando un dispositivo seriale sul mio sistema appare:
		%
		\begin{tscreen}
\verb|$| {\sl ls -l /dev/cua0} \\
\verb|crw-rw-rw-   1 root     uucp       5,  64 Nov 30  1993 /dev/cua0| \\
\verb|$| 
		\end{tscreen}
		%
	Il primo carattere della prima colonna, ad esempio `{\tt c}' nel {\tt crw-rw-rw-} qui sopra, dice agli utenti informati il tipo del file, in questo caso un dispositivo a caratteri. Per i file ordinari il primo carattere è `{\tt -}', per le directory è `{\tt d}', e per i dispositivi a blocchi `{\tt b}': leggete la pagina man di \cmd{ls} per altre informazioni.

	Notate che di solito tutti i file di device esistono anche se il dispositivo corrispondente può non essere installato. Quindi se avete un file \fn{/dev/sda} non vuol dire che avete realmente un hard disk SCSI.
Avere tutti i file di device rende più semplici i programmi di installazione, ed è più facile aggiungere nuovo hardware (non c'è bisogno di trovare i parametri corretti e creare il file di device per il nuovo dispositivo).

\section{Gli hard disk}

	In questa sezione viene introdotta la terminologia relativa agli hard disk. Se già conoscete i termini ed i concetti potete saltarla.

In figura~\ref{fig:hd-schematic} viene riportato un disegno schematico delle parti più importanti di un hard disk. Un hard disk consiste di una o più \defin{piastre} circolari\footnote{Le piastre sono fatte di un materiale duro, come l'alluminio, da cui il nome hard disk, cioè ``disco duro''.}, con entrambe le \defin{superfici} ricoperte da una sostanza magnetica usata per la memorizzazione dei dati. Per ciascuna superficie c'è una \defin{testina di lettura e scrittura} che esamina o altera i dati memorizzati. Le piastre ruotano su un asse comune, con una velocità tipica di 3600 rotazioni al minuto, anche se gli hard disk ad alte prestazioni raggiungono velocità maggiori. Le testine si spostano lungo il raggio della piastra, e questo movimento, combinato con la rotazione delle piastre, permette alla testina di accedere a tutti i punti delle superfici.


	Il processore (CPU) e il disco in sé comunicano attraverso un \defin{controller dischi}, che solleva il resto del computer dalla necessità di sapere come utilizzare il disco, dato che si possono fare diversi  tipi di controller per diversi tipi di disco, che possano usare la stessa interfaccia verso il resto del computer. Quindi il computer può dire semplicemente ``hey disco, dammi quello che voglio'', invece di una serie lunga e complessa di segnali elettrici per spostare la testina al punto desiderato, aspettare che la parte giusta ruoti sotto la testina e tutte queste cose antipatiche (in realtà, l'interfaccia al controller è comunque complessa, ma molto meno di come sarebbe dovuta essere altrimenti). Il controller può anche fare altre cose, come la cache, o l'isolamento automatico dei settori danneggiati.

	Quello che è stato spiegato finora è di solito tutto quello che bisogna sapere sull'hardware. Ci sono anche molte altre cose, come il motore che fa girare le piastre e sposta le testine, e l'elettronica che controlla le operazioni delle parti meccaniche, ma tutto questo non è rilevante per la comprensione del principio di funzionamento di un hard disk.

	Le superfici sono di solito divise in anelli concentrici, chiamati \defin{tracce}, e queste a loro volta sono divise in \defin{settori}. Questa divisione viene usata per specificare punti dell'hard disk e per allocare lo spazio disco per i file. Per trovare un punto determinato dell'hard disk si potrebbe dire ``piastra 3, traccia 5, settore 7''. Di solito il numero dei settori è lo stesso per tutte le tracce, ma in qualche hard disk ci sono più tracce nei settori più esterni (tutti i settori sono delle stesse dimensioni fisiche, quindi nelle tracce più esterne ce ne entrano di più). Tipicamente, un settore conterrà 512~byte di dati. Il disco stesso non può gestire quantità di dati più piccole di un settore.

		\begin{figure}[thb]
		\begin{center}
		\includegraphics{disks/hd-schematic.ps}
		\end{center}
		\caption{Schema di un hard disk.}
		\label{fig:hd-schematic}
		\end{figure}

	Ciascuna superficie è divisa in tracce (e settori) nello stesso modo. Ciò significa che quando la testina di una superficie è su una traccia, la testina per l'altra superficie è anch'essa sulla traccia corrispondente. Tutte le tracce corrispondenti prese insieme si chiamano \defin{cilindro}.  Ci vuole del tempo per spostare le testine da una traccia (cilindro) ad un'altra, quindi mettendo i dati a cui si accede in contemporanea (diciamo un file) in modo che si trovino tutti all'interno dello stesso cilindro, non è necessario spostare la testina per leggerli tutti, e viene migliorata la performance del disco. Non è sempre possibile mettere i file in questo modo: i file che vengono immagazzinati in posti diversi dell'hard disk vengono chiamati \defin{frammentati}.


	Il numero di superfici (o testine, che è la stessa cosa), cilindri e settori variano molto: le specifiche sul numero di ciascuno di questi elementi vengono chiamate \defin{geometria} di un hard disk. La geometria viene di solito memorizzata in una locazione di memoria speciale, alimentata a batterie, chiamata \defin{RAM CMOS}, da cui il sistema operativo la può leggere durante l'avvio del computer o l'inizializzazione dei driver.

	Sfortunatamente, il BIOS\footnote{Il BIOS è un software fisso immagazzinato nei chip della ROM. Ha il compito, tra le altre cose, degli stadi iniziali del processo di avvio.} ha una limitazione che rende impossibile specificare un numero di tracce più alto di 1024 nella RAM CMOS, che è troppo poco per un hard disk grande. Per superare questo problema il controller degli hard disk mente sulla geometria, e \defin{tradurre gli indirizzi} dati dal computer in qualcosa di reale. Ad esempio, un hard disk può avere 8 testine, 2048 tracce e 35 settori per traccia\footnote{I numeri sono completamente inventati.}. Il suo controller può mentire al computer e dire che ha 16 testine, 1024 tracce e 35 settori per tracce, non superando quindi il limite per le tracce, e traduce gli indirizzi che il computer gli dà dimezzando il numero di testina e raddoppiando il numero di traccia. La matematica può in realtà essere molto più complicata, perché i numeri in genere non sono così carini (ma i dettagli non sono rilevanti per la comprensione del principio). Questa traduzione distorce la visione del sistema operativo di come è organizzato il disco, rendendo poco pratico usare il trucco di mettere tutti i dati su uno stesso cilindro per aumentare la performance.

	La traduzione è un problema solo per i dischi IDE. I dischi SCSI usano un numero di settori sequenziale (cioè il controller traduce un numero di settore sequenziale nella tripletta testina, cilindro e settore), ed un metodo totalmente diverso per la comunicazione tra la CPU e il controller, quindi il problema non si pone. Notate, comunque, che il computer può non sapere la geometria reale neanche di un disco SCSI.


	Dato che Linux spesso non conoscerà la geometria reale di un disco, i suoi filesystem non provano neanche a mantenere i file all'interno di un singolo cilindro; provano invece ad assegnare ai file settori numerati sequenzialmente, cosa che dà quasi sempre una performance simile. La questione è complicata ancora dalle cache sul controller, e dai precaricamenti automatici fatti dal controller stesso.

	Ciascun hard disk è rappresentato da un file di device separato. Di solito ci possono essere solo due o quattro hard disk IDE, che corrispondono rispettivamente a \fn{/dev/hda}, \fn{/dev/hdb}, \fn{/dev/hdc}, e \fn{/dev/hdd}. Gli hard disk SCSI corrispondono a \fn{/dev/sda}, \fn{/dev/sdb} e così via. Esistono delle convenzioni simili anche per altri tipi di hard disk: per altre informazioni vedere la~\cite{device-list}. Notare che i file di device per gli hard disk danno accesso al disco intero, senza considerare le partizioni (che verranno spiegate più avanti), ed è facile rovinare i dati in essi contenuti se non si fa attenzione. I file di device dei dischi di solito vengono usati solo per accedere al loro master boot record (che verrà ugualmente spiegato più avanti).


\section{I floppy}

	Un floppy disk consiste di una membrana flessibile coperta su uno solo o su entrambi i lati con una sostanza magnetica simile a quella degli hard disk. Il floppy in sé non ha una testina di lettura e scrittura, che è inclusa nel lettore. Un floppy corrisponde ad una piastra di un hard disk, ma è rimuovibile ed un lettore può essere usato per accedere a diversi floppy, mentre l'hard disk è una singola unità indivisibile.

	Come un hard disk, un floppy è suddiviso in tracce e settori (e le due tracce corrispondenti sui due lati di un floppy formano un cilindro), ma ce ne sono meno che su un hard disk.

	Un lettore di floppy può di solito usare diversi tipi di dischi: ad esempio, un lettore di dischi da $3{1\over 2}$ pollici può usare sia dischi da 720~kB che da 1.44~MB. Dato che il lettore deve operare in maniera leggermente diversa e che il sistema operativo deve conoscere la dimensione del disco, ci sono più file di device per ciascun lettore di floppy, uno per ciascuna combinazione di lettore e tipo di disco. Quindi, \fn{/dev/fd0H1440} è il primo lettore di floppy (\texttt{fd0}), che corrisponde ad un lettore a $3{1\over 2}$ pollici, che usa un dischetto da $3{1\over 2}$ pollici ad alta densità (\texttt{H}) di dimensioni  1440~kB (\texttt{1440}), cioè un normale floppy da $3{1\over 2}$ HD. Per altre informazioni sulle convenzioni per i nomi dei dispositivi floppy, vedere la~\cite{device-list}.


	I nomi dei drive dei floppy sono complessi, comunque, e Linux ha quindi un tipo di device floppy che individua il tipo di hard disk nel lettore; funziona provando a leggere i primi settori di un dischetto inserito nel lettore usando diversi tipi di floppy finché trova quello corretto. Naturalmente ciò richiede che il dischetto sia prima stato formattato. I device automatici sono \fn{/dev/fd0}, \fn{/dev/fd1}, e così via.

	I parametri che il device automatico usa per accedere ad un disco possono essere impostati anche usando il programma \cmd{setfdprm}. Una cosa del genere può essere utile se dovete usare dei dischi che non seguono le normali dimensioni dei floppy: ad esempio se hanno un numero di settori non usuale, o se per qualche ragione il riconoscimento automatico non funziona e manca il corrispondente file di device.

	Linux può gestire molti formati non standard di floppy in aggiunta a tutti quelli standard. Alcuni di questi richiedono di usare dei programmi di formattazione speciali. 
Non esamineremo questi tipi di disco ora, ma nel frattempo potete esaminare il file \fn{/etc/fdprm}, che specifica le impostazioni riconosciute da \cmd{setfdprm}.

Il sistema operativo deve sapere quando viene cambiato il disco nel drive dei floppy, ad esempio, per evitare di usare dati messi in cache dal disco precedente. Sfortunatamente, la linea di segnale che viene usata per questo qualche volta non funziona e, peggio, non sarà sempre individuabile da MS-DOS. Se avete degli strani problemi quando usate i floppy, forse la ragione è questa. L'unico modo di correggere questo problema è riparare il drive dei floppy.

\section{I CD-ROM}

	I drive del CD-ROM usano un disco a lettura ottica ricoperto di plastica. Le informazioni vengono registrati sulla superficie del disco\footnote{Cioè la superficie del disco, sul disco di metallo all'interno della copertura di plastica.} in piccoli `fori' allineati lungo una spirale dal centro verso l'esterno. Il drive dirige un raggio laser lungo la spirale per leggere il disco. Quando il laser colpisce un buco, il raggio viene riflesso in un modo, quando colpisce la superficie liscia viene riflesso in un altro, rendendo facile codificare i bit, e quindi le informazioni. Il resto è facile, semplice meccanica.

	I drive dei CD-ROM sono lenti se paragonati agli hard disk. Mentre un tipico hard disk avrà un tempo di ricerca medio minore di 15~millisecondi, un CD-ROM veloce userà per una ricerca dei decimi di secondo; una velocità di trasferimento dati reale di centinaia di kilobyte al secondo è piuttosto alta. La lentezza sta a significare che i drive del CD-ROM non sono comodi da usare al posto degli hard disk (alcune distribuzioni di Linux forniscono filesystem `live' su CD-ROM, rendendo inutile copiare i file sull'hard disk, e quindi facilitando l'installazione e salvando molto spazio su disco), anche se è sempre possibile. Per installare nuovo software, i CD-ROM sono molto validi, perché non è essenziale una velocità altissima durante l'installazione.

	Ci sono diversi modi di sistemare i dati su un CD-ROM; il modo più comune è specificato dallo standard internazionale ISO~9660. Questo standard specifica un filesystem minimale, anche più povero di quello usato dall'MS-DOS; d'altra parte, è talmente minimale che qualsiasi sistema operativo dovrebbe essere in grado di mapparlo sul suo sistema nativo.

	Per l'uso normale sotto UNIX non si può usare il filesystem ISO~9660, quindi è stata sviluppata un estensione allo standard: l'estensione Rock Ridge. La Rock Ridge permette di usare nomi più lunghi, link simbolici e molte altre caratteristiche, rendendo un CD-ROM molto simile ad un qualsiasi filesystem UNIX contemporaneo. Ancora meglio, un filesystem Rock Ridge è ancora un filesystem ISO~9660 valido, e quindi può essere usato anche su sistemi non UNIX. Linux supporta sia l'ISO~9660 che l'estensione Rock Ridge, e le estensioni vengono riconosciute ed utilizzate automaticamente.

	Il filesystem è però solo metà lavoro. La maggior parte dei CD-ROM contengono dati che richiedono programmi speciali per potervi accedere, e la maggior parte di questi programmi non girano sotto Linux (eccetto forse sotto dosemu, l'emulatore di MS-DOS per Linux).

	Si accede ai drive di CD-ROM attraverso il corrispondente file di device. Ci sono diversi modi di connettere un drive di CD-ROM al computer: attraverso un controller SCSI, una scheda audio o un controller EIDE. Il montaggio dell'hardware va al di fuori dello scopo di questo libro, ma il tipo di connessione implica quale file di device venga usato. Vedere~\cite{device-list} per avere chiarimenti.


\section{I nastri}

	I lettori nastro usano dei nastri simili\footnote{Ma del tutto diversi, naturalmente.} alle cassette usate per la musica. Un nastro è di sua natura seriale, cioè per accedere  ad una sua qualsiasi parte bisogna scorrere tutto quello che c'è in mezzo; un disco è un dispositivo ad accesso casuale, cioè si può passare direttamente ad un suo punto qualsiasi. L'accesso seriale dei nastri li rende dispositivi lenti.
  
	D'altra parte, i nastri sono relativamente a buon mercato, dato che non hanno bisogno di essere veloci. Possono avere anche una lunghezza elevata, e quindi contenere grandi quantità di dati; ciò li rende molto adatti a cose come l'archiviazione e i backup, che non richiedono velocità elevate ma traggono vantaggio dal basso costo e dalla grande capacità di immagazzinamento.

\section{La formattazione}

	\defin{La formattazione} è il processo con cui si segnano sul mezzo magnetico le tracce e i settori. Prima che venga formattato, il disco ha una superficie in cui i segnali magnetici si sovrappongono creando un vero caos. Quando viene formattato si porta un certo ordine nel caos essenzialmente tracciando delle linee dove vanno le tracce e dove vengono suddivise in settori. I dettagli reali non sono proprio questi, ma è irrilevante; quello che è importante è che un disco non può essere usato se non è stato formattato.

	La terminologia a questo proposito è piuttosto confusa: nell'MS-DOS, la parola formattazione viene usata anche per il processo di creazione di un filesystem (che verrà discusso più avanti); qui i due processi sono spesso combinati, specialmente per i floppy. Quando sarà necessaria una distinzione, la formattazione reale viene chiamata \defin{formattazione a basso livello}, mentre la creazione del filesystem si chiama \defin{formattazione ad alto livello}. Nei circoli UNIX, i due processi vengono chiamati formattazione e creazione di un filesystem, quindi in questo libro verranno usati questi termini.

	Per i dischi IDE ed alcuni dischi SCSI la formattazione viene fatta in realtà in fabbrica, e non c'è bisogno di ripeterla, quindi la maggior parte delle persone non avranno bisogno di preoccuparsene. In effetti, formattare un hard disk può provocarne un malfunzionamento, perché può essere necessario formattarlo in maniera particolare per far rimpiazzare automaticamente i settori danneggiati.

	I dischi che devono o possono essere formattati spesso richiedono comunque un programma speciale, dato che l'interfaccia alla logica di formattazione all'interno del disco è diversa da caso a caso. Il programma di formattazione spesso è sul BIOS del controller, oppure viene fornito come programma MS-DOS, e in nessuno dei due casi si può usare facilmente da Linux.

	Durante la formattazione si possono incontrare dei punti danneggiati sul disco, che vengono chiamati \defin{blocchi danneggiati} o \defin{settori danneggiati}. Qualche volta vengono gestiti dallo stesso drive, ma anche in questi casi, se se ne sviluppano altri, bisogna fare qualcosa per evitare di usare quelle parti del disco. La logica per farlo è inglobata nel filesystem; come aggiungere le informazioni nel filesystem viene descritto qui sotto. Alternativamente si può creare una piccola partizione che ricopra solo la parte danneggiata del disco: può essere una buona idea se si è danneggiata una parte piuttosto grande, dato che i filesystem possono avere dei problemi con aree danneggiate molto grandi. 

	I floppy vengono formattati con \cmd{fdformat}. Il file di device del floppy da usare viene dato come parametro; ad esempio, il comando seguente formatterebbe un dischetto ad alta densità, da $3{1\over 2}$ pollici nel primo drive del floppy:

                %
                \begin{tscreen}
\verb|$| {\sl fdformat /dev/fd0H1440} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... done| \\
\verb|$ |
                \end{tscreen}
                %
	Notate che se volete usare un dispositivo che venga rilevato automaticamente (ad esempio \fn{/dev/fd0}, {\em dovete} per prima cosa impostarne i parametri con \cmd{setfdprm}. Per avere lo stesso effetto del comando qui sopra, bisognerebbe fare così:
		%
		\begin{tscreen}
\verb|$| {\sl setfdprm /dev/fd0 1440/1440} \\
\verb|$| {\sl fdformat /dev/fd0} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... done| \\
\verb|$ |
		\end{tscreen}
		%
	Di solito è più conveniente scegliere il file di device corretto
che corrisponda al tipo di floppy. Notate che non è saggio formattare i floppy con una capacità maggiore di quella per cui sono stati progettati. 


	\cmd{fdformat} convaliderà anche il floppy, cioè controllerà che non ci siano blocchi danneggiati. Proverà a leggere e scrivere su un blocco danneggiato diverse volte (lo si può sentire, dato che il rumore del drive cambia moltissimo). Se il floppy è solo leggermente danneggiato (a causa dello sporco sulla testina del drive alcuni errori sono segnali falsi), \cmd{fdformat} non si lamenterà, ma un errore reale farà abortire il processo di convalida. Il kernel stamperà dei messaggi di log per ogni errore di I/O che trova, messaggi che andranno in console o, se si usa \cmd{syslog}, nel file \fn{/usr/adm/messages}. \cmd{fdformat} non dice dove si trova l'errore (di solito non ci interessa, i floppy sono abbastanza a buon mercato da poterne buttare uno automaticamente, se è danneggiato).
		%
		\begin{tscreen}
\verb|$| {\sl fdformat /dev/fd0H1440} \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|Verifying ... read: Unknown error| \\
\verb|$ |
		\end{tscreen}
		%

	Per cercare soltanto i blocchi danneggiati su un disco o su una partizione si usa il comando \cmd{badblocks} (anche per i floppy). Non formatta il disco, quindi lo si può usare anche su filesystem esistenti. L'esempio qui sotto controlla un floppy da $3{1\over 2}$ pollici con due blocchi danneggiati.
		%
		\begin{tscreen}
\verb|$| {\sl badblocks /dev/fd0H1440 1440} \\
\verb|718| \\
\verb|719| \\
\verb|$ |
		\end{tscreen}
		%
	\cmd{badblocks} rende in output i numeri dei blocchi che trova danneggiati. La maggior parte dei filesystem riesce ad evitarli; mantengono un elenco dei blocchi danneggiati, che viene inizializzato quando viene creato il filesystem, e può essere modificato in seguito. La prima ricerca dei blocchi danneggiati può essere fatta con il comando \cmd{mkfs} (che inizializza il filesystem), ma i controlli successivi vanno fatti con \cmd{badblocks}, ed i nuovi blocchi dovrebbero essere aggiunti con \cmd{fsck}. Descriveremo \cmd{mkfs} e \cmd{fsck} più avanti.

	Molti dischi moderni individuano automaticamente i blocchi danneggiati, e tentano di recuperarli usando al loro posto un blocco speciale, integro, riservato per questo scopo, che è invisibile al sistema operativo. Questa caratteristica dovrebbe essere documentata nel manuale del disco, se siete curiosi di sapere se ce l'avete. Anche dischi di questo tipo possono rovinarsi, se il numero di blocchi danneggiati diventa troppo grande, anche se è probabile che a quel punto il disco sarebbe troppo rovinato per essere utile.

\section{Le partizioni}

	Un singolo hard disk può essere diviso in diverse \defin{partizioni}.
Ciascuna partizione funziona come se fosse un disco separato; l'idea è che se avete un hard disk, e ad esempio volete avere due sistemi operativi, potete suddividere il disco in due partizioni. Ciascun sistema operativo usa la sua partizione come vuole e non tocca quella dell'altro. In questo modo i due sistemi operativi possono coesistere in pace sullo stesso hard disk; senza le partizioni se ne sarebbe dovuto comprare uno per ciascun sistema operativo.

	I floppy non vengono partizionati, non per motivi tecnici, ma perché sono molto piccoli, e creare al loro interno delle partizioni non sarebbe utile se non in casi molto rari. I CD-ROM di solito non vengono partizionati, dato che è molto più semplice usarli come un grande disco, e in genere non è necessario avere diversi sistemi operativi sullo stesso CD-ROM.

\subsection{Il MBR, i settori di boot e la tabella delle partizioni}

	Le informazioni sul partizionamento di un hard disk si trovano nel suo primo settore (cioè, il primo settore della prima traccia della prima superficie del disco). Il primo settore si chiama \defin{master boot record} (MBR) del disco: è il settore che il BIOS legge ed avvia quando la macchina viene accesa.
Il master boot record contiene un piccolo programma che legge la tabella delle partizioni, controlla quale partizione è attiva (cioè quale è contrassegnata avviabile) e legge il primo settore di quella partizione, il \defin{boot sector} (settore di avvio) della partizione (anche l'MBR è un settore di avvio, ma ha uno status speciale e quindi un nome speciale). Il boot sector contiene un altro programmino che legge la prima parte del sistema operativo contenuto in quella partizione (sempre che sia avviabile) e lo avvia.

	Lo schema di partizionamento non è costruito all'interno dell'hardware, e nemmeno nel BIOS. \`E solo una convenzione che viene seguita da molti sistemi operativi: non tutti, ma quelli che non lo fanno sono le eccezioni. Alcuni sistemi operativi permettono l'uso di partizioni, ma occupano una partizione sull'hard disk, ed usano il loro metodo di partizionamento interno lì dentro. Quest'ultimo tipo coesiste pacificamente con gli altri sistemi operativi (incluso Linux), e non richiede misure speciali, ma un sistema operativo che non supporta le partizioni non può coesistere sullo stesso disco con un altro sistema. 

	Come precauzione è una buona idea scrivere su carta la tabella delle partizioni, in modo che se si corrompesse ci sarebbe una speranza di non perdere tutti i file (una tabella delle partizioni corrotta si può recuperare con \cmd{fdisk}). Le informazioni rilevanti si ricavano dal comando \cmd{fdisk -l}:
		%
	\begin{tscreen}
\verb|$| \textsl{fdisk -l /dev/hda} \\
\verb|| \\
\verb|Disk /dev/hda: 15 heads, 57 sectors, 790 cylinders| \\
\verb|Units = cylinders of 855 * 512 bytes| \\
\verb|| \\
\verb|   Device Boot  Begin   Start     End  Blocks   Id  System| \\
\verb|/dev/hda1           1       1      24   10231+  82  Linux swap| \\
\verb|/dev/hda2          25      25      48   10260   83  Linux native| \\
\verb|/dev/hda3          49      49     408  153900   83  Linux native| \\
\verb|/dev/hda4         409     409     790  163305    5  Extended| \\
\verb|/dev/hda5         409     409     744  143611+  83  Linux native| \\
\verb|/dev/hda6         745     745     790   19636+  83  Linux native| \\
\verb|$|
	\end{tscreen}

\subsection{Partizioni estese e partizioni logiche}
	
	Lo schema di partizionamento originale degli hard disk dei PC permetteva solo quattro partizioni, ma presto questo si è dimostrato troppo poco per l'uso reale, perché alcune persone volevano più di quattro sistemi operativi (Linux, MS-DOS, OS/2, Minix, FreeBSD, NetBSD, o Windows NT, per nominarne alcuni), ma principalmente perché qualche volta è una buona idea avere diverse partizioni per un solo sistema operativo. Ad esempio per Linux è meglio mettere lo spazio di swap in una sua partizione, per motivi di velocità (vedi sotto).

	Per superare questo problema di progettazione, furono create le \defin{partizioni estese}. Questo trucco permette di partizionare una \defin{partizione primaria} in sotto-partizioni. La partizione primaria così suddivisa è la partizione estesa, e le sottopartizioni sono \defin{partizioni logiche}: si comportano come partizioni primarie\footnote{Illogiche?}, ma vengono create in maniera diversa. Non comportano una differenza di velocità.

	La struttura delle partizioni di un hard disk può apparire come in figura~\ref{fig:hard-disk-layout}. Il disco viene diviso in tre partizioni primarie, la seconda delle quali è divisa in due partizioni logiche. Parte del disco non viene partizionato. Il disco intero e ciascuna partizione primaria hanno un settore di boot.

		\begin{figure}[thb]
		\begin{center}
		\includegraphics{disks/hd-layout.ps}
		%\include{hd-layout}
		\end{center}
		\caption{Un esempio di partizionamento di hard disk.}
		\label{fig:hard-disk-layout}
		\end{figure}

\subsection{Tipi di partizione}

	Le tabelle delle partizioni (quelle nell'MBR, e quelle per le partizioni estese) contengono un byte per partizione che identifica il tipo di partizione. In questo modo si cerca di identificare il sistema operativo che usa la partizione, o il modo in cui viene usata. Lo scopo è evitare che due sistemi operativi usino accidentalmente la stessa partizione; comunque, in realtà, i sistemi operativi non considerano il tipo della partizione: ad esempio, Linux proprio non lo legge. Peggio ancora, alcuni sistemi lo usano in maniera non corretta; ad esempio, almeno alcune versioni di DR-DOS ignorano il bit più significativo del byte, altre no.

	Non c'è nessuna agenzia di standardizzazione che specifica cosa significhi ciascun valore di questo byte, ma alcuni valori comunemente accettati sono riportati in tabella \ref{tab:partition-ids}. La stessa lista è disponibile nel programma \cmd{fdisk} di Linux.

\begin{table}[ht]
\caption{Tabella delle partizioni (dal programma \cmd{fdisk} di Linux).}
\begin{center}
\begin{tabular}{rl rl rl rl}
\hline
0 & Vuota               & 40 & Venix 80286   & 94 & Amoeba BBT     \\
1 & DOS 12-bit FAT      & 51 & Novell?       & a5 & BSD/386        \\
2 & XENIX root          & 52 & Microport     & b7 & BSDI fs        \\
3 & XENIX usr           & 63 & GNU HURD      & b8 & BSDI swap      \\
4 & DOS 16-bit $<$32M   & 64 & Novell        & c7 & Syrinx         \\
5 & Estesa              & 75 & PC/IX         & db & CP/M           \\
6 & DOS 16-bit $\ge$32M & 80 & MINIX Vecchio & e1 & DOS access     \\
7 & OS/2 HPFS           & 81 & Linux/MINIX   & e3 & DOS R/O        \\
8 & AIX                 & 82 & Linux swap    & f2 & DOS secondaria \\
9 & AIX bootabile       & 83 & Linux nativa  & ff & BBT            \\
a & OS/2 Boot Manag     & 93 & Amoeba        &    &                \\
\hline
\end{tabular}
\end{center}
\label{tab:partition-ids}
\end{table}

\subsection{Ripartizionare un hard disk}

	Ci sono molti programmi per creare e rimuovere partizioni. La maggior parte dei sistemi operativi ne ha uno proprio, ed è una buona idea usare quello del sistema che si usa, in caso faccia qualcosa di insolito che gli altri non fanno. La maggior parte di questi programmi, compreso quello per Linux, si chiamano \cmd{fdisk}, o variazioni sul tema. I dettagli sull'uso dell'\cmd{fdisk} di Linux sono riportati nella sua pagina man. Il comando \cmd{cfdisk} è simile a \cmd{fdisk}, ma ha un'interfaccia utente più carina (a tutto schermo).

	Quando si usano dei dischi IDE, la partizione di boot (quella con i file di immagine del kernel che si avvia) deve essere completamente all'interno dei primi 1024 cilindri, perché il disco viene usato dal BIOS durante l'avviamento del sistema (prima che i sistema vada in modalità protetta), e il BIOS non può gestire più di 1024 cilindri. Talvolta è possibile usare una partizione di boot che è solo parzialmente entro i primi 1024 cilindri: questo trucco funziona solo se tutti i file che vengono letti dal BIOS sono entro il cilindro 1024. Dato che una cosa del genere è difficile da imporre, è \emph{una pessima idea} provarci: non saprete mai quando un aggiornamento del kernel o la deframmentazione del disco vi renderà non avviabile il sistema; quindi, assicuratevi che la partizione di boot sia completamente all'interno dei primi 1024 cilindri.

	Alcune versioni più recenti del BIOS e dei dischi IDE possono, in effetti, gestire dischi con più di 1024 cilindri. Se avete un sistema di questo genere, potete dimenticarvi del problema; se non ne siete sicuri, mettetela comunque entro i primi 1024 cilindri.

	Ciascuna partizione dovrebbe avere un numero pari di settori, dato che i filesystem di Linux usano blocchi di 1~kb, cioè due settori. Un numero dispari di settori comporterà il mancato utilizzo dell'ultimo settore; una cosa del genere non crea problemi, ma è brutto, e alcune versioni di \cmd{fdisk} vi daranno un avvertimento.
	
	Modificare la dimensione di una partizione di solito richiede di fare il backup di tutto (preferibilmente di tutto il disco, non si sa mai), cancellare la partizione, crearne una nuova, e rimettere tutti i dati. Se la partizione deve aumentare, dovrete anche modificare la dimensione (e fare il backup e il
restore) anche delle partizioni confinanti.

	Dato che modificare la dimensione di una partizione è una cosa complicata, è preferibile dimensionarle bene la prima volta, o avere un mezzo di backup efficace e facile da usare. Se state installando da un mezzo che non richiede molto intervento umano (ad esempio un CD-ROM, e non un floppy), spesso è più facile giocare con diverse configurazioni all'inizio: dato che non avete dati di cui fare backup, non è poi così doloroso modificare le dimensioni delle partizioni diverse volte. 

	Esiste un programma per l'MS-DOS, chiamato \cmd{fips}, che ridimensiona le partizioni MS-DOS senza dover fare backup e recuperare tutti i dati, ma per gli altri filesystem è ancora necessario.


\subsection{File di device e partizioni}

	Ciascuna partizione e partizione estesa ha il proprio file di device. La convenzione per i nomi di questi file è che il numero della partizione viene fatto seguire al nome del disco, con la convenzione che da 1 a 4 sono partizioni primarie (non tenendo conto di quante partizioni primarie ci sono in realtà), e da 5 a 8 sono partizioni logiche (non tenendo conto di quale è la partizione primaria che le contiene). Ad esempio, \fn{/dev/hda1} è la prima partizione primaria sul primo disco IDE, e \fn{/dev/sdb7} è la terza partizione estesa sul secondo disco SCSI. 
L'elenco dei device in~\cite{device-list} dà altre informazioni su questo argomento.


\section{I filesystem}
\label{sec:filesystems}

\subsection{Che cosa sono i filesystem?}

	Un \defin{filesystem} comprende i metodi e le strutture di dati usate da un sistema operativo per tenere traccia dei file su un hard disk o su una sua partizione, cioè il modo in cui i file sono organizzati sui dischi. La parola viene anche usata per riferirsi ad una partizione o a un disco usato per immagazzinare i file, o al tipo del filesystem. Quindi si può dire ``ho due filesystem'', per dire che si hanno due partizioni in cui immagazzinare file, o che si sta usando ``l'extended filesystem'', per indicare il tipo di filesystem.


	La differenza tra un disco o una partizione ed il filesystem che contiene è molto importante. Alcuni programmi (compreso, abbastanza ragionevolmente, i programmi che creano i filesystem) operano direttamente sui settori del disco o della partizione; se c'è un filesystem esistente, questo verrà distrutto o seriamente danneggiato. La maggior parte dei programmi operano su un filesystem, e quindi non funzioneranno su una partizione che non ne contiene uno (o ne contiene uno del tipo sbagliato).


	Prima che si possa usare un disco o una partizione come filesystem, deve essere inizializzato, e bisogna scriverci le strutture di dati per l'archiviazione. Questo processo si chiama \defin{creazione di un filesystem}. 

	La maggior parte dei tipi di filesystem UNIX hanno una struttura generale simile, anche se i dettagli esatti cambiano abbastanza. I concetti centrali sono quelli di \defin{superblocco}, \defin{inode}, \defin{blocco dati}, \defin{blocco directory} e \defin{blocco indirezione}. Il superblocco contiene delle informazioni sul filesystem intero, come la sua dimensione (l'informazione esatta qui dipende dal filesystem). Un inode contiene tutte le informazioni su un file, eccetto il suo nome, che viene immagazzinato nella directory, insieme con il numero dell'inode. Una voce di directory consiste del nome di un file e del numero dell'inode che rappresenta il file. L'inode contiene il numero di diversi blocchi dati, che vengono usati per immagazzinare i dati del file. Nell'inode c'è posto solo per alcuni numeri di blocchi dati, ma se ne servono più viene allocato dinamicamente più spazio per i puntatori ai blocchi dati. Questi blocchi allocati dinamicamente sono blocchi indiretti; il nome indica che per trovare i blocchi dati bisogna trovare prima il numero all'interno del blocco indiretto.

%	\meta this needs rewriting.  
	I filesystem UNIX di solito permettono di creare un \defin{buco} in un file (si fa con \cmd{lseek}; controllate la pagina man), cioè il filesystem fa solo finta che in un posto particolare nel file ci sono solo byte zero, ma per quel posto nel file non viene riservato nessun settore di disco reale (cioè il file userà un po' meno spazio disco). Accade spesso solo per i file binari piccoli, le librerie condivise di Linux, alcuni database ed alcuni altri casi speciali (i buchi sono implementati immagazzinando un valore speciale come indirizzo del blocco dati nel blocco indiretto o nell'inode. Questo indirizzo speciale significa che non viene allocato nessun blocco dati per quella parte del file, e quindi c'è un buco nel file).


	I buchi sono moderatamente utili. Sul sistema dell'autore, una semplice misura ha mostrato un potenziale per circa 4~MB di risparmio usando buchi, su un totale di 200~MB di spazio disco usato. Quel sistema, però, contiene pochi programmi e nessun file di database. Lo strumento di misura viene descritto nell'appendice~\ref{chap:measure-holes}.


\subsection{Filesystem a go-go}

	Linux supporta diversi tipi di filesystem. Al momento in cui sto scrivendo, i più importanti sono:
		%
	\begin{dispitems}
	\item[minix]
		Il più vecchio, e si presume il più affidabile, ma piuttosto limitato (mancano alcuni time stamp, e i nomi di file sono al massimo di 30 caratteri) e di capacità ristrette (al massimo 64~MB per filesystem).
	\item[xia]
		Una versione modificata del filesystem minix, che alza i limiti sulla lunghezza dei nomi di file e sulla dimensione dei filesystem, ma non introduce nuove caratteristiche. Non è molto conosciuto, ma si dice funzioni molto bene.
	\item[ext2]
		Il più completo dei filesystem nativi di Linux, e al momento anche il più usato. \`E disegnato per essere compatibile in avanti, in modo che nuove versioni del codice del filesystem non abbiano bisogno di rifare i filesystem esistenti.
	\item[ext]
		Una versione più vecchia dell'\texttt{ext2} che non era compatibile in avanti. Non è usato quasi mai in nuove installazioni, perché la maggior parte delle persone si sono convertite all'\texttt{ext2}.
	\end{dispitems}
		%
	Oltre a questi vengono supportati molti filesystem di altri sistemi operativi, per rendere più semplice lo scambio di file; questi filesystem funzionano come quelli nativi, tranne per la mancanza di alcune caratteristiche normali di quelli UNIX, oppure hanno delle limitazioni curiose, o altre stranezze.
		%
	\begin{dispitems}
	\item[msdos]
		Compatibilità con i filesystem FAT di MS-DOS (e OS/2 e Windows NT).
	\item[umsdos]
		Estende il driver del filesystem \texttt{msdos} sotto Linux, in modo da avere i nomi di file lunghi, i permessi, i link e i file di device, e da assegnare ciascun file ad un utente. In questo modo è possibile usare un normale filesystem \texttt{msdos} come se fosse uno Linux, eliminando la necessità di avere una partizione separata per Linux.
	\item[iso9660]
		Il filesystem standard per i CD-ROM: viene supportata automaticamente l'estensione Rock Ridge allo standard per i CD-ROM, che permette di avere i nomi dei file lunghi.
	\item[nfs]
		Un filesystem di rete che permette di condividere un filesystem tra vari computer per avere da essi un accesso più facile ai file.
	\item[hpfs]
		Il filesystem di OS/2.
	\item[sysv]
		I filesystem SystemV/386, Coherent e Xenix.
	\end{dispitems}
		%
	La scelta del filesystem da usare dipende dalla situazione. Se ci sono ragioni di compatibilità o altre ragioni che rendono indispensabile l'uso di uno dei filesystem non nativi, deve essere usato quello. Se si può scegliere liberamente, allora probabilmente la scelta più saggia è l'ext2, dato che ha tutte le caratteristiche e la sua performance è la migliore.

	Esiste anche il filesystem \texttt{proc}, di solito accessibile nella directory \fn{/proc}, che in realtà non è per niente un filesystem, anche se gli assomiglia. Il filesystem \texttt{proc} permette di avere facile accesso ad alcune strutture di dati del kernel, come la lista dei processi (da cui il nome). Fa apparire queste strutture di dati come un filesystem, e quel filesystem può essere manipolato con i normali strumenti di manipolazione di file. Ad esempio, per avere un elenco di tutti i processi si può usare il comando
		%
		\begin{tscreen}
\verb|$ | {\sl ls -l /proc} \\
\verb|total 0| \\
\verb|dr-xr-xr-x   4 root     root            0 Jan 31 20:37 1| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 63| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 94| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 95| \\
\verb|dr-xr-xr-x   4 root     users           0 Jan 31 20:37 98| \\
\verb|dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 99| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 devices| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 dma| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 filesystems| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 interrupts| \\
\verb|-r--------   1 root     root      8654848 Jan 31 20:37 kcore| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 11:50 kmsg| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 ksyms| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 11:51 loadavg| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 meminfo| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 modules| \\
\verb|dr-xr-xr-x   2 root     root            0 Jan 31 20:37 net| \\
\verb|dr-xr-xr-x   4 root     root            0 Jan 31 20:37 self| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 stat| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 uptime| \\
\verb|-r--r--r--   1 root     root            0 Jan 31 20:37 version| \\
\verb|$ |
		\end{tscreen}
		%
	(ci saranno alcuni file in più che non corrispondono a processi. L'esempio qui sopra è stato accorciato).

	Notate che anche se si chiama filesystem, nessuna parte del filesystem \texttt{proc} tocca nessun disco: esiste solo nell'immaginazione del kernel. Quando si cerca di guardare una qualsiasi parte del filesystem \texttt{proc}, il kernel fa sembrare che esista da qualche parte, ma non lo fa. Quindi, anche se c'è un file \fn{/proc/kcore} di qualche mega, non prende spazio disco.

\subsection{Quale filesystem bisogna usare?}

	Di solito non ci sono molte ragioni per usare diversi filesystem. Al momento, l'ex2fs è il più comune, e probabilmente è la scelta più saggia. A seconda delle necessità globali di strutture di archiviazione, velocità, affidabilità (visibile), compatibilità e svariate altre ragioni può essere consigliabile usare un altro filesystem. La scelta va fatta caso per caso.


\subsection{Creare un filesystem}\label{sec:mkfs}

	I filesystem vengono creati, cioè inizializzati, con il comando \cmd{mkfs}. In realtà esiste un programma separato per ciascun tipo di filesystem, e \cmd{mkfs} è solo un'interfaccia che avvia il programma adatto a seconda del tipo di filesystem desiderato. Il tipo viene selezionato con l'opzione \texttt{-t tipofs}. 

	I programmi richiamati da \cmd{mkfs} hanno interfacce su linea di comando leggermente diverse. Le opzioni più comuni ed importanti sono riassunte qui sotto; per altri dettagli consultare la pagina man. 
	%
	\begin{quote}
	\begin{description}
	\item[{\tt -t} {\it tipofs}] Seleziona il tipo di filesystem.
	\item[{\tt -c}] Attiva la ricerca dei blocchi danneggiati e ne inizializza di conseguenza la lista.
	\item[{\tt -l} {\it nomefile}] Legge la lista di blocchi daneggiati iniziale dal file {\it nomefile}.
	\end{description}
	\end{quote}
	%
	Per creare un filesystem ext2 su un floppy, si dovrebbero dare i seguenti comandi:
		%
		\begin{tscreen}
\verb|$| {\sl fdformat -n /dev/fd0H1440 } \\
\verb|Double-sided, 80 tracks, 18 sec/track. Total capacity 1440 kB.| \\
\verb|Formatting ... done| \\
\verb|$| {\sl badblocks /dev/fd0H1440 1440 $>$ blocchi-dann} \\
\verb|$| {\sl mkfs -t ext2 -l blocchi-dann /dev/fd0H1440} \\
\verb|mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10| \\
\verb|360 inodes, 1440 blocks| \\
\verb|72 blocks (5.00%) reserved for the super user| \\
\verb|First data block=1| \\
\verb|Block size=1024 (log=0)| \\
\verb|Fragment size=1024 (log=0)| \\
\verb|1 block group| \\
\verb|8192 blocks per group, 8192 fragments per group| \\
\verb|360 inodes per group| \\
\verb||\\
\verb|Writing inode tables: done     | \\
\verb|Writing superblocks and filesystem accounting information: done| \\
\verb|$|
		\end{tscreen}
		%
	Per prima cosa il floppy è stato formattato (l'opzione \texttt{-n} fa in modo che non vengano ricercati i blocchi danneggiati); poi viene attivata la ricerca con \cmd{badblocks}, con l'output rediretto in un file, \texttt{blocchi-dann}. Infine, si è creato il filesystem, con l'elenco dei blocchi danneggiati letto da quello che era stato trovato dal comando \cmd{badblocks}.

	Si poteva usare nello stesso modo l'opzione {\tt -c} di \cmd{mkfs}, invece di \cmd{badblocks} ed un file separato, come riportato nell'esempio qui sotto.
		%
		\begin{tscreen}
\verb|$| {\sl mkfs -t ext2 -c /dev/fd0H1440} \\
\verb|mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10| \\
\verb|360 inodes, 1440 blocks| \\
\verb|72 blocks (5.00%) reserved for the super user| \\
\verb|First data block=1| \\
\verb|Block size=1024 (log=0)| \\
\verb|Fragment size=1024 (log=0)| \\
\verb|1 block group| \\
\verb|8192 blocks per group, 8192 fragments per group| \\
\verb|360 inodes per group| \\
\verb| | \\
\verb|Checking for bad blocks (read-only test): done| \\
\verb|Writing inode tables: done     | \\
\verb|Writing superblocks and filesystem accounting information: done| \\
\verb|$ |
		\end{tscreen}
		%
	L'opzione {\tt -c} è più conveniente che usare separatamente \cmd{badblocks}, ma \cmd{badblocks} è indispensabile per i controlli dopo la creazione del filesystem. 

	Il processo per preparare i filesystem sugli hard disk o sulle partizioni è lo stesso che per i floppy, tranne che non è necessaria la formattazione.	


\subsection{Montare e smontare}\label{subsec:mount}

	Prima che si possa usare un filesystem, bisogna \defin{montarlo} (\defin{mount}); così il sistema operativo fa delle operazioni di archiviazione in modo da essere sicuri che tutto funzioni. Dato che tutti i file in UNIX si trovano in un singolo albero di directory, l'operazione di mount farà sembrare che il nuovo filesystem sia contenuto in una sottodirectory esistente di qualche filesystem già montato.

	Ad esempio, la figura~\ref{fig:hd-mount-root} mostra tre filesystem separati, ciascuno con la propria directory di root; quando gli ultimi due vengono montati sotto \fn{/home} e \fn{/usr}, sul primo filesystem, abbiamo un singolo albero di directory, come in figura~\ref{fig:hd-mount-all}.

		\begin{figure}[thb]
		\begin{center}
		\includegraphics{disks/hd-mount-separate.ps}
		\end{center}
		\caption{Tre filesystem separati.}
		\label{fig:hd-mount-root}
		\end{figure}

		\begin{figure}[thb]
		\begin{center}
		\includegraphics{disks/hd-mount-mounted.ps}
		\end{center}
		\caption{Sono stati montati \fn{/home} e \fn{/usr}.}
		\label{fig:hd-mount-all}
		\end{figure}

	I comandi per montare questi due filesystem sono riportati nel seguente esempio:
		%
		\begin{tscreen}
\verb|$ | {\sl mount /dev/hda2 /home} \\
\verb|$ | {\sl mount /dev/hda3 /usr} \\
\verb|$ |
		\end{tscreen}
		%
	Il comando \cmd{mount} accetta due argomenti: il file di device corrispondente al disco o alla partizione che contiene il filesystem, e la directory sotto cui montarlo. Dopo questi comandi il contenuto dei due filesystem sembrano essere in \fn{/home} e \fn{/usr}. Si può dire che ``\fn{/dev/hda2} \defin{è montato su} \fn{/home}'', e la stessa cosa per \fn{/usr}. Per vedere i due filesystem basta guardare nella directory su cui è stato montato, come se fosse una qualsiasi altra directory. Notate la differenza tra il file di device \fn{/dev/hda2} e la directory su cui viene montato, \fn{/home}. Il file di device dà accesso ai contenuti fisici del disco, la directory su cui viene montato dà accesso ai file che vi si trovano. La directory su cui viene montato un filesystem si chiama \defin{punto di mount}.


	Linux supporta molti tipi di filesystem; \cmd{mount} cerca di indovinare il tipo di quello che si sta montando. Si può anche usare l'opzione {\tt -t \sl tipofs} per specificare direttamente il tipo: tavolta è necesaria, dato che l'euristica usata da \cmd{mount} non sempre funziona. Ad esempio per montare un floppy MS-DOS si usa il seguente comando:
		%
		\begin{tscreen}
\verb|$ | {\sl mount -t msdos /dev/fd0 /floppy} \\
\verb|$ |
		\end{tscreen}
		%
	La directory di mount può anche non essere vuota, ma deve esistere. Qualsiasi file vi si trovi non potrà essere richiamato per nome mentre il filesystem è montato (qualsiasi file già aperto sarà ancora accessibile. I file a cui puntano hard link da altre directory possono essere accessibili usando quei nomi). Con questo procedimento non viene perso nessun dato, e può anche essere utile: ad esempio, alcuni vogliono avere \fn{/tmp} e \fn{/var/tmp} sinonimi, e rendere \fn{/tmp} un link simbolico a \fn{/var/tmp}. Quando si avvia il filesystem, prima che venga montato \fn{/usr}, viene usata una directory \fn{/var/tmp} che risiede sul filesystem di root. Quando viene montato \fn{/usr}, la directory \fn{/var/tmp} sul filesystem di root diventa inaccessibile. Se non esistesse \fn{/var/tmp} sul filesystem di root, sarebbe impossibile usare i file temporanei prima del mount di \fn{/var}.

	Se non volete scrivere niente su un filesystem, usate lo switch {\tt -r} per montarlo \defin{a sola lettura}; in questo modo il kernel interromperà qualsiasi tentativo di scrivere sul filesystem, ed eviterà di aggiornare i tempi di accesso ai file negli inode. \`E indispensabile usare i mount a sola lettura per i mezzi non scrivibili, come i CD-ROM.

	Il lettore attento avrà già notato un piccolo problema logistico: come viene montato il primo filesystem (chiamato \defin{filesystem di root}, perché contiene la directory principale), dato che ovviamente non può essere montato su un altro filesystem? Beh, la risposta è che si usa la magia.\footnote{Per altre informazioni, consultate i sorgenti del kernel o la Kernel Hackers' Guide.} Il filesystem di root viene montato magicamente all'avvio, e si può contare sul fatto che sia sempre montato---se non si può montare il filesystem di root, il sistema non parte. Il nome del filesystem che viene montato magicamente come root è compilato nel kernel o impostato usando LILO o \cmd{rdev}.

	Il filesystem di root viene di solito montato inizialmente a sola lettura. Gli script di avvio poi attivano \cmd{fsck} per verificare che sia valido, e se non ci sono problemi lo \defin{rimonteranno} con i permessi di scrittura. \cmd{fsck} non deve essere usato su un filesystem montato, dato che qualsiasi modifica al filesystem mentre sta girando \cmd{fsck} {\em farà} dei danni. Dato che il filesystem di root è montato a sola lettura perché viene controllato, \cmd{fsck} può correggere qualsiasi problema senza preoccupazioni, dato che l'operazione di remount ripulirà tutti i metadati che il filesystem tiene in memoria.

	Su molti sistemi ci sono altri filesystem che devono essere montati automaticamente al momento dell'avvio, e vengono specificati nel file \fn{/etc/fstab}; consultate la pagina man di \man{fstab} per avere dettagli sul suo formato. i dettagli di quando esattamente vengono montati i vari filesystem dipendono da molti fattori, e possono essere configurati, se serve, dall'amministratore. Quando sarà finito il capitolo sull'avvio, ne potrete leggere lì.

	Quando non serve più che un filesystem sia montato, può essere smontato usando \cmd{umount}\footnote{In effetti dovrebbe essere \cmd{unmount}, ma la {\tt n} è scomparsa misteriosamente negli anni '70, e non è stata più vista da allora. Per favore, se la trovate, riconsegnatela alla Bell Labs, NJ.}. \cmd{umount} accetta un argomento, o il file di device o il punto di mount. Ad esempio, per smontare le directory dell'esempio precedente, si possono usare i comandi
		%
		\begin{tscreen}
\verb|$ | {\sl umount /dev/hda2 } \\
\verb|$ | {\sl umount /usr} \\
\verb|$ |
		\end{tscreen}
		%
	Consultare la pagina man per avere altre istruzioni su come usare il comando. \`E indispensabile smontare sempre i floppy montati. {\em Non li tirate direttamente fuori dal drive!} A causa delle operazioni di cache su disco, i dati non vengono necessariamente scritti sul floppy finché non lo smontate, quindi rimuovendo il floppy dal drive troppo presto se ne possono corrompere i contenuti. Se leggete solo dal floppy non è molto probabile, ma se ci scrivete, anche accidentalmente, i risultati possono essere catastrofici.

	Montare e smontare un filesystem richiedono privilegi di superutente, cioè lo può fare solo \fn{root}; la ragione è che se chiunque potesse montare un dischetto su una qualsiasi directory, sarebbe piuttosto facile creare un floppy diciamo con un Trojan horse camuffato da \cmd{/bin/sh}, o da un qualsiasi programma usato spesso. Comunque, spesso è necessario permettere agli utenti di usare i floppy, ed ecco alcuni modi per poterlo fare:
		%
\begin{itemize}
	\item Dare agli utenti la password di \fn{root}. Ovviamente è un buco di sicurezza, ma è la soluzione più facile, ed è adatta a quei sistemi dove non c'è comunque bisogno di sicurezza, come è il caso di molti sistemi personali, che non sono in rete.
	\item Usare un programma come \cmd{sudo} per permettere agli utenti di usare mount. Anche questo dà problemi di sicurezza, ma non dà direttamente privilegi di superutente a chiunque.\footnote{Richiede da parte dell'utente diversi secondi di concentrazione.}
	\item Fare usare agli utenti \cmd{mtools}, un pacchetto per manipolare i filesystem MS-DOS senza montarli. Funziona bene se l'unica cosa che serve sono dischetti MS-DOS, altrimenti è piuttosto complicato. 
	\item Elencare i dispositivi floppy e i loro punti di mount permessi, insieme con le opzioni adatte, in \fn{/etc/fstab}.
\end{itemize}
		%
	L'ultima alternativa può essere implementata aggiungendo una linea come la seguente al file \fn{/etc/fstab}:
		%
		\begin{tscreen}
/dev/fd0            /floppy      msdos   user,noauto      0     0
		\end{tscreen}
		%
	Le colonne sono: file di device da montare, directory su cui montarlo, tipo di filesystem, opzioni, frequenza di backup (usata da \cmd{dump}) e numero di passaggio di \cmd{fsck} (per specificare l'ordine in cui controllare i filesystem all'avvio: con 0 non vengono controllati). L'opzione \texttt{noauto} non fa montare automaticamente il filesystem all'avvio del sistema (cioè non lo fa montare da \cmd{mount -a}). L'opzione \texttt{user} permette a qualsiasi utente di montare il filesystem, e per sicurezza disabilita l'esecuzione di programmi (normali o setuid) e l'interpretazioni di file di device dal filesystem montato. Fatto questo, qualsiasi utente può montare un floppy con un filesystem \texttt{msdos} con il seguente comando:
		%
		\begin{tscreen}
\verb|$ | {\sl mount /floppy} \\
\verb|$ |
		\end{tscreen}
		%
	Il floppy può (e deve, naturalmente) essere smontato con il corrispondente comando \cmd{umount}.


	Se volete dare accesso a diversi tipo di floppy, dovete dare diversi punti di mount. Le impostazioni possono essere diverse per ogni punto di mount, ad esempio, per dare accesso sia a floppy MS-DOS che ext2, si possono inserire in \fn{/etc/fstab} queste linee:
		%
		\begin{quote}
		\small
		\begin{verbatim}
/dev/fd0    /dosfloppy    msdos   user,noauto  0  0
/dev/fd0    /ext2floppy   ext2    user,noauto  0  0
		\end{verbatim}
		\end{quote}
		%
	Per i filesystem MS-DOS (non solo per i floppy) probabilmente vorrete restringerne l'accesso usando le opzioni \texttt{uid}, \texttt{gid} e \cmd{umask}, che sono descritte in dettaglio nella pagina man di \man{mount}. Se non state attenti, montare un filesystem MS-DOS dà a tutti almeno il permesso di lettura ai file che vi si trovano, che non è una buona idea.

	
\subsection{Il controllo dell'integrità di un filesystem con \cmd{fsck}}

	I filesystem sono creature complesse, e come tali tendono ad essere in qualche modo propense ad avere errori. Si possono controllare la correttezza e la validità di un filesystem usando il comando \cmd{fsck}, che può essere usato per riparare i piccoli errori che trova, e per avvisare l'utente se ci sono problemi irreparabili. Fortunatamente, al codice per implementare i filesystem viene fatto un debug piuttosto efficace, quindi in genere non ci sono problemi, e se ci sono sono causati da mancanza di corrente, guasti hardware o errori dell'operatore, ad esempio non fare correttamente lo shutdown del sistema.

	La maggior parte dei filesystem fanno \cmd{fsck} automaticamente all'avvio del sistema, in modo che gli errori vengono individuati (e, speriamo, corretti) prima che il filesystem venga usato. Usare un filesystem corrotto tende a peggiorare le cose: se le strutture di dati non sono integre, usare il filesystem probabilmente le peggiorerà, e verranno persi ancora più dati. Comunque, \cmd{fsck} può metterci un po' di tempo per controllare un filesystem grande, e dato che non ci sono quasi mai errori se il sistema viene spento in modo corretto, si possono usare un paio di trucchi per evitare di fare il controllo in casi del genere: il primo è che se esiste il file \fn{/etc/fastboot} non vengono fatti controlli. Il secondo è che il filesystem ext2 ha un codice speciale nel superblocco che dice se il filesystem è stato smontato in maniera corretta; in questo modo \cmd{e2fsck} (la versione di \cmd{fsck} per filesystem ext2) può evitare di controllare i filesystem se è stato smontato correttamente (l'assunzione è che se il filesystem è stato smontato bene non ci sono problemi). La validità del trucco del file \fn{/etc/fastboot} dipende dallo script di avvio, ma il trucco dell'ext2 funziona tutte le volte che si usa \cmd{e2fsck}---per evitarlo deve essere esplicitamente indicata un'opzione (consultate la pagina man di \man{e2fsck} per i dettagli).


	Il controllo automatico funziona solo per i filesystem che vengono montati automaticamente all'avvio; usate \cmd{fsck} a mano per gli altri, come ad esempio per i floppy.

	Se \cmd{fsck} trova dei problemi irrecuperabili dovete avere una conoscenza profonda di come funzionano in generale i filesystem, e del tipo del filesystem corrotto in particolare, oppure dovete avere dei buoni backup. La seconda possibilità è più facile (anche se spesso più noiosa), per la prima ci si può appoggiare ad un amico, o ai newsgroup e alle mailing list su Linux, o ad una qualche altra forma di aiuto, se non avete voi stessi le nozioni necessarie. Mi piacerebbe dirvi di più sull'argomento, ma mi trattiene la mia mancanza di esperienza e di educazione in questo campo. Vi dovrebbe essere utile il programma \cmd{debugfs} di Theodore T'so.

	\cmd{fsck} deve essere usato solo sui filesystem non montati, mai su quelli montati (con l'eccezione della root a sola lettura durante l'avvio), perché accede al disco a basso livello, e quindi può modificare il filesystem senza che il sistema operativo se ne accorga. \`E \emph{veramente} un problema, se si confonde il sistema operativo.


\subsection{Il controllo degli errori sul disco con \cmd{badblocks}}

	Può essere una buona idea controllare periodicamente se ci sono blocchi danneggiati, con il comando \cmd{badblocks}, che dà in output un elenco dei numeri dei blocchi danneggiati che trova. Si può usare questa lista per farla registrare nelle strutture dati del filesystem a \cmd{fsck} in modo che il sistema operativo non provi ad usare i blocchi danneggiati per scriverci dei dati. Nell'esempio viene spiegato come fare:
		%
		\begin{tscreen}
\verb|$| {\sl badblocks /dev/fd0H1440 1440 $>$ bad-blocks } \\
\verb|$| {\sl fsck -t ext2 -l bad-blocks /dev/fd0H1440} \\
\verb|Parallelizing fsck version 0.5a (5-Apr-94)| \\
\verb|e2fsck 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10| \\
\verb|Pass 1: Checking inodes, blocks, and sizes| \\
\verb|Pass 2: Checking directory structure| \\
\verb|Pass 3: Checking directory connectivity| \\
\verb|Pass 4: Check reference counts.| \\
\verb|Pass 5: Checking group summary information.| \\
\verb| | \\
\verb|/dev/fd0H1440: ***** FILE SYSTEM WAS MODIFIED *****| \\
\verb|/dev/fd0H1440: 11/360 files, 63/1440 blocks| \\
\verb|$ |
		\end{tscreen}
		%
	Se \cmd{badblocks} riporta un blocco che già è stato usato, \cmd{e2fsck} prova a spostare il blocco in un altro punto. Se il blocco è già stato veramente danneggiato, e non era solo marginale, i contenuti del file possono già essere corrotti.


\subsection{Combattere la frammentazione}

	Quando si scrive un file sul disco, non può sempre essere scritto su blocchi consecutivi. Un file che non è immagazzinato su blocchi consecutivi si definisce \defin{frammentato}. Ci vuole più tempo per leggere un file frammentato, dato che la testina di lettura e scrittura del disco si deve spostare di più. \`E preferibile evitare la frammentazione, anche se è meno problematico in un sistema con una buona cache di buffer con il read-ahead.

	Il filesystem ext2 tenta di mantenere la frammentazione al minimo, tenendo tutti i blocchi di un file vicini, anche se non possono essere immagazzinati in settori consecutivi. L'ext2 in effetti alloca sempre il blocco libero che si trova più vicino agli altri blocchi di un file. Per l'ext2, quindi, è molto raro doversi preoccupare della frammentazione. Esiste un programma di deframmentazione per un filesystem ext2: consultate~\cite{ext2-defrag} nella bibliografia.

	Ci sono molti programmi di deframmentazione per MS-DOS che spostano i blocchi nel filesystem per rimuovere la deframmentazione. Per altri tipi di filesystem si deve fare un backup completo, ricreare il filesystem e recuperare i dati dai backup. Fare il backup prima di deframmentare un filesystem è comunque una buona idea, dato che molte cose possono andare storte nel processo.


\subsection{Altri strumenti per tutti i filesystem}

	Anche altri strumenti sono utili per gestire i filesystem: \cmd{df} mostra lo spazio disco libero  su uno o più filesystem, \cmd{du} quello preso da una directory e da tutti i suoi file. Si possono usare entrambi questi comandi per ricercare chi spreca spazio disco.

	\cmd{sync} forza la scrittura sul disco di tutti i blocchi non scritti nella cache del buffer (vedi la sezione~\ref{sec:buffer-cache}). Normalmente non c'è bisogno di farlo a mano: lo fa automaticamente il processo daemon \cmd{update}. Può essere utile in caso di catastrofe, ad esempio se \cmd{update} o il suo aiutante \cmd{bdflush} muoiono, o se dovete interrompere la corrente \cmd{now} e non potete aspettare che venga avviato \cmd{update}.

\subsection{Altri strumenti per il filesystem ext2}

	In aggiunta al comando per creare i filesystem (\cmd{mke2fs}) e quello per controllarli (\cmd{e2fsck}), accessibili direttamente o attraverso le interfacce indipendenti dal tipo di filesystem, il filesystem ext2 ha altri strumenti utili.

	\cmd{tune2fs} migliora i parametri del filesystem. Alcuni di quelli più interessanti sono:
		%
	\begin{itemize}
	\item Il numero massimo di mount. \cmd{e2fsck} forza un controllo ogni volta che un filesystem viene montato troppe volte, anche se ha il codice di filesystem integro. Per un sistema che viene usato per sviluppare o testare il sistema, può essere una buona idea ridurre questo limite.
	\item Un tempo massimo tra i controlli. \cmd{e2fsck} può anche forzare il tempo massimo tra due controlli, anche se c'è il codice di filesystem pulito, e il filesystem non è stato montato molto spesso. Questo parametro può essere anche disabilitato.
	\item Il numero di blocchi riservato per \texttt{root}. L'ext2 riserva alcuni blocchi per \texttt{root} in modo che se il filesystem si riempie, sia ancora possibile fare dell'amministrazione di sistema senza dover cancellare niente. La percentuale riservata è per default del 5%, che sulla maggior parte dei dischi non è tanto da essere uno spreco. Comunque, per e floppy non c'è motivo per riservare niente.
	\end{itemize}
		%
	Consultate la pagina man di \man{tune2fs} per altre informazioni.

	\cmd{dumpe2fs} dà delle informazioni su un filesystem ext2, prese per la maggior parte dal suo superblocco. In figura~\ref{fig:dumpe2fs-output} viene mostrato un esempio di output. Alcune delle informazioni dell'output sono tecniche e richiedono una compresione di come funziona il filesystem (vedere l'appendice~\ref{chap:ext2fspaper}), ma la paggior parte è facilmente comprensibile.

\begin{figure}[t]
\begin{center}
\small
\begin{verbatim}
dumpe2fs 0.5b, 11-Mar-95 for EXT2 FS 0.5a, 94/10/23
Filesystem magic number:  0xEF53
Filesystem state:         clean
Errors behavior:          Continue
Inode count:              360
Block count:              1440
Reserved block count:     72
Free blocks:              1133
Free inodes:              326
First block:              1
Block size:               1024
Fragment size:            1024
Blocks per group:         8192
Fragments per group:      8192
Inodes per group:         360
Last mount time:          Tue Aug  8 01:52:52 1995
Last write time:          Tue Aug  8 01:53:28 1995
Mount count:              3
Maximum mount count:      20
Last checked:             Tue Aug  8 01:06:31 1995
Check interval:           0
Reserved blocks uid:      0 (user root)
Reserved blocks gid:      0 (group root)

Group 0:
  Block bitmap at 3, Inode bitmap at 4, Inode table at 5
  1133 free blocks, 326 free inodes, 2 directories
  Free blocks: 307-1439
  Free inodes: 35-360
\end{verbatim}
\end{center}
\caption{Output di esempio di \cmd{dumpe2fs}}
\label{fig:dumpe2fs-output}
\end{figure}

	\cmd{debugfs} è un debugger per i filesystem: permette accesso diretto alle sue strutture dati immagazzinate sul disco, e quindi può essere usato per riparare un disco talmente danneggiato da non poter essere recuperato automaticamente con \cmd{fsck}. \`E stato anche usato per recuperare dei file cancellati; comunque, \cmd{debugfs} richiede di capire a fondo quello che si sta facendo: se non riuscite a capire qualcosa potreste distruggere tutti i dati.

	Per fare il backup di un filesystem ext2 si possono usare \cmd{dump} e \cmd{restore}: sono versioni specifiche per l'ext2 degli strumenti tradizionali di backup di UNIX. Vedere il capitolo~\ref{chap:backups} per altre informazioni sui backup.

\section{Dischi senza filesystem}

	Non tutti i dischi o le partizioni vengono usati come filesystem: ad esempio le partizioni di swap non hanno filesystem. Molti floppy vengono usati come fossero dei nastri, scrivendo direttamente un \cmd{tar} o un altro file sul disco vuoto, senza un filesystem. I floppy di boot di Linux non contengono filesystem, ma solo un kernel nudo e crudo.

	Evitare il filesystem ha il vantaggio di rendere utilizzabile una parte maggiore del disco, dato che il filesystem ha sempre una parte di archiviazione. Rende anche il disco più facilmente compatibile con gli altri sistemi: ad esempio, il formato dei file \cmd{tar} è lo stesso su tutti i sistemi, mentre i filesystem sono diversi sulla maggior parte dei sistemi. Vi abituerete presto ai dischi senza filesystem se ne avrete bisogno. Anche i floppy di boot di Linux non hanno necessariamente un filesystem, anche se anche quello è possibile.

	Una ragione di usare i dischi senza filesystem è che se ne possono fare copie identiche. Ad esempio, se il disco contiene un filesystem parzialmente danneggiato, è una buona idea farne una copia esatta prima di tentare di ripararlo, in modo da poter ricominciare da capo se cercando di aggiustarlo lo si danneggia ancora di più. Un modo di farlo è usare \cmd{dd}:
		%
		\begin{tscreen}
\verb|$| {\sl dd if=/dev/fd0H1440 of=floppy-image} \\
\verb|2880+0 records in| \\
\verb|2880+0 records out| \\
\verb|$| {\sl dd if=floppy-image of=/dev/fd0H1440 } \\
\verb|2880+0 records in| \\
\verb|2880+0 records out| \\
\verb|$|
		\end{tscreen}
		%
	Il primo \cmd{dd} crea un'immagine esatta del floppy nel file \fn{floppy-image}, il secondo copia l'immagine nel floppy (presumibilmente l'utente ha cambiato floppy prima del secondo comando, altrimenti la coppia di comandi non è molto utile).


\section{Allocare spazio disco}

\subsection{Schemi di partizionamento}

	Non è facile partizionare un disco nel modo migliore possibile. Peggio ancora, non c'è nessun modo corretto per farlo, ma ci sono troppi fattori coinvolti.

	Il modo normale per farlo è avere un filesystem di root (relativamente) piccolo, che contenga \fn{/bin}, \fn{/etc}, \fn{/dev}, \fn{/lib}, \fn{/tmp} ed altre cose necessarie per fare partire il filesystem. In questo modo il filesystem di root (nella sua partizione o sul suo disco) è tutto quello che serve per avviare il sistema. Il ragionamento è che se il filesystem di root è piccolo e non viene usato pesantemente, è meno probabile che venga corrotto quando si ha un crash del sistema, e quindi sarà più facile risolvere qualsiasi problema causato dal crash. Allora si creano delle partizioni separate o si usano dischi separati per l'albero delle directory sotto \fn{/usr}, per le home directory degli utenti (di solito sotto \fn{/home}) e lo spazio di swap. Separare le home directory (con i file degli utenti) in una partizione separata rende più facili i backup, dato che spesso non è necessario fare il backup dei programmi (che risiedono sotto \fn{/usr}). In un ambiente di rete è anche possibile condividere \fn{/usr} tra svariate macchine (ad esempio usando NFS), e riducendo così lo spazio disco totale richiesto da diverse decine o centinaia di megabyte moltiplicato per il numero di macchine.


	Il problema di avere molte partizioni è che divide lo spazio libero totale in piccoli pezzi; oggigiorno che i dischi e (speriamo) i sistemi operativi sono più affidabili, molte persone preferiscono avere solo una partizione che contenga tutti i file. D'altra parte può essere meno doloroso fare il backup (e il restore) di una partizione piccola.
	
%	\meta more reasons for many partitions: users/temp files/spools
%	can't fill up all disks, readonly partitions less likely to corrupt, 
%	fsck is faster, limits losses a filesystem goes really wrong,
%	logging must not be disturbed, boots from >1023 cylinders do not
%	work on all BIOS's, /usr/local won't be disturbed by an upgrade,
%	easy to divide backup on many tapes, spare (scratch) partition for
%	experimentation (e.g., a new Linux distribution), scratch can
%	also be used to backup root during upgrades

	Per un hard disk piccolo (assumendo che non sviluppate il kernel), il modo migliore è probabilmente avere una sola partizione. Per dischi grandi è probabilmente meglio avere qualche partizione grande, giusto in caso vada bene qualcosa (notate che `piccola' o `grande' sono termini usati in senso relativo: le soglie sono dettate dal vostro bisogno di spazio disco).

	Se avete più di un disco potete pensare di tenere il filesystem di root (compreso \fn{/usr}) su uno, e le home degli utenti su un altro.

	\`E una buona idea essere pronti a sperimentare un po' con diversi schemi di partizionamento (nel tempo, non solo alla prima installazione del sistema). \`E un lavoraccio, dato che richiede essenzialmente di reinstallare il sistema da zero diverse volte, ma è l'unico modo di essere sicuri di farlo bene.


\subsection{Requisiti di spazio}

	La distribuzione di Linux che installate darà qualche indicazione sullo spazio disco necessario per svariate configurazioni. I programmi installati separatamente possono fare lo stesso. In questo modo vi sarà possibile pianificare l'uso dello spazio disco, ma dovreste prepararvi per il futuro e riservare dello spazio extra per le cose di cui vi accorgerete di avere bisogno in futuro.

	La quantità di spazio che vi serve per i file degli utenti dipende da cosa vogliono fare i vostri utenti. Sembra che la maggior parte delle persone abbiano bisogno del più spazio possibile per i propri file, ma la quantità con cui vivranno in pace varia molto: alcuni lavorano solo sui testi e sopravviveranno con qualche megabyte, altri fanno manipolazione pesante di immagini e avranno bisogno di gigabyte.

	Tra l'altro, quando si paragonano le dimensioni dei file in kilobyte o in megabyte e lo spazio disco misurato in megabyte, è importante sapere che le due unità possono essere diverse. Alcuni produttori di dischi amano pensare che un kilobyte è 1000 byte e che un megabyte è 1000 kilobyte, mentre tutto il resto del mondo informatico usa 1024 per entrambi i fattori. Quindi, il mio hard disk da 345~MB in realtà è un hard disk da 330~MB.\footnote{Sic transit discus mundi.}

	L'allocazione dello spazio di swap viene discussa nella sezione~\ref{sec:swap-alloc}.


\subsection{Esempi di allocazione di hard disk}

	Io avevo un hard disk da 109~MB; ora ne uso uno da 330~MB. Spiegherò come e perché ho partizionato entrambi.

	Il disco da 109~MB l'ho partizionato in moltissimi modi, a seconda delle mie necessità e dei sistemi operativi che usavo: per prima cosa usavo l'MS-DOS insieme a Linux; per quello avevo bisogno più o meno di 20~MB di hard disk, o lo spazio appena sufficiente per avere l'MS-DOS, un compilatore C, un editor, pochi altri programmi, quello su cui stavo lavorando e il minimo spazio per non farmi sentire claustrofobico. Per Linux avevo una partizione di swap di 10~MB,  ed i resto, o 79~MB, era una partizione singola con tutti i file che avevo sotto Linux. Ho sperimentato con delle partizione di root, \fn{/usr} e \fn{/home} separate, ma non c'era mai abbastanza spazio disco libero insieme per fare qualcosa di interessante. 

	Quando non ho più avuto bisogno dell'MS-DOS, ho ripartizionato l'hard disk in modo di avere una partizione di swap di 12~MB, ed il resto di nuovo in un singolo filesystem.
	
	Il disco da 330~MB è partizionato in diverse partizioni, così:
		%
		\begin{quote}
		\begin{tabular}{r l}
	  	  5 MB & filesystem di root \\
	 	 10 MB & partizione di swap \\
		180 MB & filesystem \fn{/usr} \\
		120 MB & filesystem \fn{/home} \\
	 	 15 MB & partizione di scratch 
		\end{tabular}
		\end{quote}
		%
	La partizione di scratch è per giocherellare con cose che richiedono una propria partizione, cioè provare diverse distribuzioni di Linux, o paragonare le velocità dei filesystem. Quando non serve per nient'altro, la uso come spazio di swap (mi piace tenere {\em moltissime} finestre aperte).


\subsection{Aggiungere altro spazio disco per Linux}

	Aggiungere altro spazio disco per Linux è facile, almeno dopo che l'hardware è stato installato correttamente (l'installazione dell'hardware va oltre lo scopo di questo libro): si formatta, se necessario, poi si creano le partizioni ed i filesystem come è stato spiegato nei paragrafi precedenti, e si aggiungono le linee adatte in \fn{/etc/fstab} in modo che venga montato automaticamente.


\subsection{Suggerimenti per risparmiare lo spazio su disco}

	Il modo migliore per risparmiare spazio disco è evitare di installare programmi non necessari. La maggior parte delle distribuzioni hanno un'opzione per installare solo una parte dei pacchetti che contengono, e analizzando le vostre necessità potrete accorgervi di non aver bisogno della maggior parte di essi. Vi aiuterà a risparmiare spazio disco, dato che molti programmi sono piuttosto grandi. Anche se avete bisogno di un pacchetto o di un programma particolare, non è detto che vi servano tutti. Ad esempio può non essere necessaria della documentazione in linea, o dei file Elisp di GNU Emacs, alcuni font di X11, o alcune delle librerie di programmazione.

	Se non potete disinstallare i pacchetti, potete provare a comprimerli. I programmi di compressione come \cmd{gzip} o \cmd{zip} comprimono (e decomprimono) file individuali o gruppi di file. Il sistema \cmd{gzexe} comprime e decomprime i programmi in maniera invisibile all'utente (i programmi che non vengono usati vengono compressi, e decompressi quando si usano). Il sistema sperimentale \cmd{DouBle} comprime tutti i file di un filesystem, in maniera invisibile ai programmi che li usano (se avete familiarità con prodotti come Stacker per l'MS-DOS, il principio è lo stesso).






