Sartomiki.net

Struttura del file system
Un file system ha il compito di fornire i meccanismi di accesso e memorizzazione dei file. Esso risiede permanentemente in memoria secondaria e deve essere in grado di contenere grosse quantità di dati. Durante la progettazione di un file system si incontrano immediatamente due problemi:
-il fs deve presentarsi in modo intuitivo all'utente, deve permettere alcune funzionalità di base e deve consentire all'utente di organizzare in modo logico i propri file.
-il fs deve utilizzare algoritmi e strutture dati efficienti in grado di far corrispondere il fs logico con il dispositivo fisico su cui deve risiedere.
Normalmente la struttura di un file system è stratificata. Ogni livello si serve dei livelli sottostanti per creare i livelli superiori:
-dispositivo. Il dispositivo su cui risiede il file system.
-controllore I/O. E' costituito dai driver del dispositivo e dai gestori dei segnali di interrupt e consente di trasferire le informazioni dalla memoria secondaria, alla memoria centrale e viceversa. Esso riceve dei segnali di alto livello e li converte in istruzioni di basso livello in grado di pilotare direttamente il dispositivo.
-file system id base, che ha lo scopo di inviare al controllore i comandi di alto livello specifici per leggere e scrivere specifici blocchi fisici.
-modulo di organizzazione dei file, esso ha lo scopo di tradurre i blocchi di memoria logici (numerati da 0 a n) in blocchi di memoria fisici (organizzati in maniera differente a seconda del supporto).
-file system logico, esso ha lo scopo di gestire la struttura delle directory e di organizzare i file in strutture apposite (file contro block, FCB).
-applicazioni che utilizzano il file system.
Al giorno d'oggi esiste un numero cospicuo di file system e non è raro che sistemi operativi ne prevedano più di uno. Ad esempio UNIX adotta UFS, che si fonda su FFS. Windows e i supporti ottici utilizzano FAT, FAT32, NTFS. Linux è in grado di supportare più di quaranta file system, quello standard si chiama EXT3. Esistono inoltre file system distribuiti.

Realizzazione del file system
Per realizzare un file system sono necessarie alcune strutture dati, che variano a seconda del file system e del sistema operativo. Esistono, tuttavia, alcune strutture comuni a molte configurazioni:
-blocco di controllo dell'avviamento, che contiene le informazioni essenziali per eseguire il boot del sistema operativo su quel volume. Normalmente è posizionato nelle primissime posizioni del volume. Nell'UFS esso prende il nome di boot block, mentre nell'NTFS viene detto partition boot sector.
-blocchi di controllo dei volumi, che contengono i dettagli del volume (dimensioni e numero dei blocchi, blocchi disponibili, file liberi per ogni blocco…). Nell'UFS viene detto superblocco, mentre nell'NTFS master file table (MFT).
-strutture delle directory, che sono usate per organizzare i file. Nell'UFS sono composte dai nomi dei file e dagli inode ad essi associati, mentre in NTFS queste informazioni sono contenute nella MFT.
-blocchi di controllo di file (FCB), che sono utilizzati per contenere i dettagli relativi ai file, come i permessi, i proprietari, le dimensioni, le locazioni… Nell'UFS sono detti inode, mentre nell'NTFS queste informazioni sono memorizzate nella MFT.
Esistono altre strutture all'interno di un file system, che servono sia per la gestione del file system stesso, sia per migliorare le sue prestazioni, attraverso l'uso di cache. Alcune strutture sono:
-tabella di montaggio della memoria, che contiene diverse informazioni sui volumi montati.
-struttura delle directory, che contiene le informazioni di tutte le directory.
-tabella dei file aperti, contenente una copia del blocco di controllo dei file aperti.
-tabella dei file aperti per ogni processo, contenente un puntatore all'elemento della tabella dei file aperti corrispondente ad ogni processo e altre informazioni.
Un esempio di utilizzo di queste strutture si ha nel momento della creazione di un nuovo file. In questo caso si crea e alloca un nuovo file contro block (FCB), si carica in memoria la directory appropriata, si aggiorna la struttura della directory, aggiungendo il nome del nuovo file e l'FCB associato e la si riscrive sul disco.
Un altro esempio è quello dell'utilizzo di un file creato. In questo caso, prima di essere usato, il file deve essere aperto, mediante un'apposita chiamata di funzione. Se, dopo aver consultato la tabella dei file aperti, il file risulta apribile, viene aggiunto un puntatore alla tabella dei file aperti associata al processo che lo ha richiesto, che punta alla tabella dei file aperti del sistema. Una volta aperto si ricerca il nome del file all'interno della directory specificata nella tabella dei file aperti. Una volta trovato il file si copia l'FCB nella tabella dei file aperti, in modo da velocizzare le operazioni future su quel file (non sarà più richiesta la ricerca). In questa tabella è anche memorizzato il numero dei processi che stanno usando quel file. Nella tabella dei file aperti associata al processo, invece, viene creato un elemento (detto file descriptor), che contiene il puntatore alla posizione corrente nel file e il informazioni riguardanti il tipo di accesso. Nel momento in cui il file viene chiuso, si cancella il relativo elemento dalla tabella dei file aperti del processo e, nel caso in cui sia l'ultimo processo ad aver aperto quel file, anche dalla tabella dei file aperti di sistema e, se ci sono state modifiche, si riscrive il file su disco.
Molti file system, come quello usato da UNIX, distinguono file e directory mediante il campo tipo, mentre in Windows sono necessarie chiamate di sistema distinte per file e directory.
Alcuni file system, come UFS, nella tabella dei file aperti di sistema memorizzano anche informazioni per la gestione di dispositivi di rete.

Partizioni
Un disco si può dividere in più partizioni, nel senso che su esso possono essere presenti parti con file system diversi.
Ciascuna partizione che non è munita di alcun file system viene detta raw partition. Le raw partition sono usate dai sistemi UNIX come area di avvicendamento dei processi, da alcuni sistemi che utilizzano basi di dati, o anche da architetture che supportano RAID.
L'avviamento del sistema, normalmente, viene eseguito caricando in memoria le istruzioni presenti in una partizione apposita, collocata all'inizio del disco. Queste istruzioni possono permettere l'avviamento di vari sistemi operativi attraverso un'apposito modulo, detto boot loader.
Nel momento in cui si inizia il caricamento del sistema operativo si esegue il montaggio della partizione radice (root): viene quindi caricato il kernel del sistema operativo e i file di configurazione di sistema. A seconda del sistema operativo possono essere caricati anche le altre partizioni leggibili dall'OS in modo automatico oppure no.
Durante il montaggio delle altre partizioni è necessario che venga controllato che il file system che si sta caricando è in un formato corretto. Per rendere possibile l'accesso ad una partizione, il nome e il tipo vengono annotati in una tabella. Il formato di questa tabella dipende dal sistema operativo: ad esempio Windows identifica le partizioni con una lettera maiuscola seguita da ":". In UNIX, invece, il montaggio può avvenire in qualsiasi directory, in quanto un campo dell'inode corrispondente può puntare anche a partizioni esterne.

File system virtuali
Siccome gli OS moderni devono gestire contemporaneamente più file system (fs) diversi, è necessario analizzare come poter gestire questa situazione.
Un sistema banale per gestire contemporaneamente più file system, sarebbe quella di realizzare procedure di gestione di file e directory diverse a seconda del tipo di file system. Questa soluzione porterebbe però ad un grande overhead perché si dovrebbero implementare procedure simili, ma non uguali a seconda dei fs. E' per questo motivo che gli OS moderni, come UNIX, impiegano tecniche orientate agli oggetti per gestire in maniera modulare più file system. Usando tecniche più evolute è anche possibile gestire in modo semplice file system distribuiti, come NFS.
Per isolare le funzioni di base delle chiamate dai dettagli di implementazione si utilizzano alcune strutture dati stratificate:
-interfaccia del file system dell'OS, che riceve le classiche funzioni di apertura, chiusura, scrittura e lettura, provenienti dal sistema operativo.
-file system virtuale (VFS), che opera da traduttore tra più interfacce di file system specifici e l'interfaccia dell'OS. Il VFS separa le operazioni generiche che si compiono sui file system dalla loro implementazione, rendendo possibile l'esistenza di più file system in modo trasparente all'OS. Il VFS, inoltre, ha il compito di rappresentare in maniera univoca un file su tutta la rete, mediante l'utilizzo dei vnode. Un esempio è dato dall'architettura VFS di Linux, in cui sono presenti diversi tipi: per ognuno di questi tipi, VFS specifica alcune operazioni fondamentali da implementare ed in ogni oggetto è presente un puntatore alle implementazioni di queste funzioni. I tipi sono:
--inode, che rappresenta il singolo file.
--file, che rappresenta ogni file aperto.
--superblock, che rappresenta un intero file system
--dentry, che rappresenta il singolo elemento della directory.
-file system, i vari file system.

Ripristino
In caso di malfunzionamenti è necessario che i dati in memoria secondaria non vengano persi o incoerenti.
Il problema della coerenza dei dati è provocato dal fatto che molti dati aggiornati non sono sempre contenuti in memoria secondaria, ma sono presenti in memoria centrale o nelle cache. Per evitare che interi file system risultino incoerenti, nel momento in cui viene avviato il sistema, uno speciale programma (verificatore della coerenza) controlla che i dati presenti nelle directory corrispondano a quelli descritti dalle directory stesse. Quando il programma incontra delle incoerenze, esso tenta di correggerle.
Nel caso in cui il sistema abbia un file system indicizzato, la perdita di un puntatore ad un indice, causerebbe la perdita di tutti i dati contenuti in quell'indice. E' per questo motivo che ad esempio UNIX non effettua mai operazioni di caching in scrittura, ma solo in lettura.
Per risolvere il problema della coerenza non è sufficiente questo accorgimento, in quanto i problemi si possono verificare anche durante un'operazione di scrittura. E' per questo che molti file sistemi, ereditati dalle architetture per i database, utilizzano le transazioni per registrare le modifiche (journaling file system). Secondo questi file system (NTFS, UFS, Veritas,…), dopo aver eseguito un'operazione sui metadati, essa viene registrata in un file di log. Ogni gruppo di operazioni sui metadati, che porta da uno stato iniziale coerente ad una nuova situazione coerente è detta transazione. Nel momento in cui tutta la transazione è terminata, l'elenco delle operazioni presenti nel log viene cancellato (committed). In questo modo è possibile verificare se qualche azione non è stata conclusa (aborted).  
Un metodo molto usato per evitare la perdita dei dati in caso di malfunzionamenti, è la creazione di copie di riserva (backup) periodiche, in modo da garantire l'operazione di restore. Per evitare di dover ricopiare l'intero file system ad ogni modifica, è possibile utilizzare backup incrementali.