2. libfat: Operazioni Supportate dal Filesystem SFAT

Questa sezione descrive le operazioni che devopno essere implementate nella libreria libfat.



Formattazione di un Filesystem

La funzione per la formattazione del filesystem ha il seguente prototipo:

   int fat_format (FILE *fs, int block_size, unsigned int num_block);
  

Questa funzione ha il compito di formattare un file con il formato SFAT. In particolare deve realizzare le seguenti operazioni:

Parametri:
fs puntatore al file che conterra' il file system e che deve quindi essere formattato
block_size size di ciascun blocco (in byte)
num_block numero di blocchi disponibili
Restituisce:
  • EWFCD se si verifica un errore durante la scrittura delle strutture dati utilizzate dalla SFAT.
  • 0 se la formattazione si e' conclusa con successo

La funzione e' dichiarata nel file format.h mentre la test suite per questa funzione e' specificata nel file format_suite.c

Avvertimento:
La test suite per la funzione fat_format puo' essere eseguito solo se e' stata implementata anche la funzione mount_fat.


Mounting di un Filesysem SFAT

La funzione per il caricamento di un filesystem SFAT ha il seguente prototipo:

   int 	mount_fat (FILE *fs, struct fat_ctrl *f_ctrl)
  

Questa funzione si occupa di leggere le informazioni di controllo del filesystem FAT.

Parametri:
fs il FILE pointer che consente di acceddre al file in cui il filesystem e' memorizzato.
f_ctrl il puntatore alla struttura dove memorizzare le informazioni di controllo
Restituisce:
  • ERFCD se si verifica un errore durante la lettura delle strutture dati utilizzati da SFAT.
  • 0 in caso di successo

La funzione e' dichiarata nel file load_fat.h mentre la test suite per questa funzione e' specificata nel file format_suite.c



Creazione di una Directory

La funzione per la creazione di una direcotry ha il seguente prototipo:

   int 	fat_mkdir (FILE *fs, struct fat_ctrl *f_ctrl, char *path);
  

Questa funzione ha il compito di creare una subdirectory SUBDIR all'interno di una directory DIR. Il pathname con cui si effettua la creazione della directory e' formato da DIR/SUBDIR. Ad esempio il pathname /this/is/a/path/name/example e' formato dal pathname assoluto della directory DIR= /this/is/a/path/name/ in cui si vuole creare una nuova subdirectory, ed il nome SUBDIR= example della subdirectory che si vuole creare. Ogni singola componete del pathname DIR (e.g. this is a ecc.) viene riferito con il termine path element. In particolare questa funzione ha il compito di:

Parametri:
fs il FILE pointer che consente di accedere al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path il path assoluto in cui creare la nuova directory. L'ultimo elemento del path e' il nome della nuova directory. Ad esempio se path = /home/pippo allora la directory che deve essere creata ha nome pippo e deve essere creata come subdirectory di /home.
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
  • ENTL (Error Name Too Long) uno degli elementi del pathname supera la lunghezza consentita (MAX_LEN_NAME).
  • ENSFD (Error Not Such File or Directory) se un elemento del pah non siste o non e' una directory.
  • ENMSD (Error No More Space on Device) se non ci sono piu' blocchi disponibili e quindi ci troviamo in una condizione di Filesystem Full.
  • ERFCD (Error Reading Fat Control Data) se si verifica un errore leggendo le strutture di controllo del filesystem Fat.
  • EWFCD (Error Writing Fat Control Data) se si verifica un errore durante la scrittura delle strutture di controllo del filesystem Fat.
  • 0 (zero) in caso di successo.

La funzione e' dichiarata nel file make_dir.h mentre la test suite per questa funzione e' specificata nel file mkdir_suite.c

Avvertimento:
La test suite per la funzione fat_mkdir puo' essere eseguito solo se e' stata implementata anche la funzione fat_ls .


Listing di una Directory

La funzione per il listing di una direcotry ha il seguente prototipo:

   int fat_ls(FILE *fs, struct fat_ctrl *f_ctrl, char *path, char **list)
  

Questa funzione effettua l'operazione di listing di una directory. In particolare ha il compito di generare la lista dei file e subdirectory contenute all'interno di una directory. La lista e' rappresentata da una stringa in cui i nomi dei file sono separati dal carattere '\t'. La lista non viene esplicitamente ordinata, ma i nomi appaiono nell'ordine in cui sono letti dalla directory table delle directory su cui si sta effettuando l'operazione di listing.

Parametri:
fs il FILE pointer che consente di acceddere al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path il path assoluto della directory di cui dobbiamo effettuare il listing.
list [OUT] indirizzo di un puntatore. Dopo l'elaborazione conterra' riferimento a una stringa contenente tutti i nomi dei files e delle subdirectory contenuti nella directory definita da path. I nomi sono separati dal carattere \t (tab).
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
  • ERFCD (Error Reading Fat Control Data) se si verifica un errore leggendo le strutture di controllo del filesystem Fat.
  • ENSFD (Error Not Such File or Directory) se un elemento del pah non siste o non e' una directory.
  • ERDB (Error Reading Block Data) se si verifica un errore di lettura di un blocco.
  • 0 in caso di sucesso.

La funzione e' dichiarata nel file list.h mentre la test suite per questa funzione e' specificata nel file mkdir_suite.c

Avvertimento:
La test suite per la funzione fat_ls puo' essere eseguito solo se e' stata implementata anche la funzione fat_mkdir .


Creazione di un File

La funzione per la creazione di un file ha il seguente prototipo:

   int fat_open (FILE *fs, struct fat_ctrl *f_ctrl, char *path);
  

Questa funzione ha il compito di creare un nuovo file all'interno del filesystem SFAT. Il nome del file F viene espresso tramite un pathname assoluto come ad esempio /dir/name/fileName in cui il nome del file F e' specificato dall'ultimo elemento del pathname (fileNmae) e la directrory D in cui deve essere creato il file e' specificata dalla prima parte del pathname (/dir/name ). In particolare questa funzione deve:

Parametri:
fs il FILE pointer che consente di acceddre al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path la stringa che contiene il path assoluto del file che deve essere creato.
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
  • ENTL (Error Name Too Long) uno degli elementi del pathname supera la lunghezza consentita (MAX_LEN_NAME).
  • ENSFD (Error Not Such File or Directory) se un elemento del pah non siste o non e' una directory.
  • ENMSD (Error No More Space on Device) se non ci sono piu' blocchi disponibili e quindi ci troviamo in una condizione di Filesystem Full.
  • ERFCD (Error Reading Fat Control Data) se si verifica un errore leggendo le strutture di controllo del filesystem Fat.
  • EWFCD (Error Writing Fat Control Data) se si verifica un errore durante la scrittura delle strutture di controllo del filesystem Fat.
  • 0 (zero) in caso di successo

La funzione e' dichiarata nel file open_fat.h mentre la test suite per questa funzione e' specificata nel file open_suite.c .



Scrittura di un File

La funzione per la scrittura all'interno di un file ha il seguente prototipo:

   int fat_write(FILE *fs, struct fat_ctrl *f_ctrl, char *path, char* data, int data_len);
  

Questa funzione ha il compito di scrivere una sequenza di byte all'interno di un file memorizzato in un filesystem SFAT. Osserviamo che:

Questa funzione deve realizzare le seguenti operazioni:

Parametri:
fs il FILE pointer che consente di acceddre al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path la stringa che contiene il path assoluto del file su cui effettuare la scrittura.
data il buffer contenete i nuovi dati da scrivere all'interno del file.
data_len il numero di bytes contenuti nel buffer data che debbono essere scritti nel file.
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
  • ENTL (Error Name Too Long) uno degli elementi del pathname supera la lunghezza consentita (MAX_LEN_NAME).
  • ENSFD (Error Not Such File or Directory) se un elemento del pah non siste o non e' una directory.
  • 0 se l'operazione termina con successo.

La funzione e' dichiarata nel file write_fat.h mentre la test suite per questa funzione e' specificata nel file rw_suite.c .

Avvertimento:
La test suite per la funzione write_fat.c puo' essere eseguito solo se e' stata implementata anche la funzione read_fat.c .


Lettura di un File

La funzione per la lettura di un file ha il seguente prototipo:

   int fat_read(FILE *fs, struct fat_ctrl *f_ctrl, char *path, int start, int data_len, char *data);
  

Questa funzione ha il compito di leggere una sequenza di byte di un file memorizzato all'interno di un filesystem SFAT. La sequenza viene specificata tramite due parametri:

La funzione deve:

Parametri:
fs il FILE pointer che consente di acceddre al file dove il filesystem e' memorizzato.
f_ctrl puntatore alla struttura che mantiene tutte le informazioni di controllo del filesystem.
path la stringa che contiene il path assoluto del file che deve essere letto.
start la posizione del byte da cui cominciare la lettura.
data_len il numero di byte da leggere a partire dal byte in posizone start.
data il buffer in cui copiare i dati letti dal file. Il buffer deve essere allocato opportunamente.
Restituisce:
  • EBDP (Error Bad Directory Path) se il path specificato non e' assoluto, ossia non inizia con il carattere '/'
    • In caso di successo la funzione torna un numero non negativo che indica il numero di bytes letti. Tale numero puo'risultare inferiore a data_len nel caso in cui si incontri la fine del file prima di leggere data_len bytes.

La funzione e' dichiarata nel file read_fat.h mentre la test suite per questa funzione e' specificata nel file rw_suite.c .

Avvertimento:
La test suite per la funzione read_fat.c puo' essere eseguito solo se e' stata implementata anche la funzione write_fat.c .


Avvertimento:

Con il programma definito nel file all_tests.c e' possibile eseguire con un singolo comando tutte le test suites definite per il progetto SFAT.

Generato il Fri Jan 28 22:16:32 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3