src

Riferimenti per il file hyppocampus.c

#include "hyppocampus.h"

Definizioni

#define BLOCK_BACK()
#define FORWARD_BLOCK()
#define JUMP_NEXT_HEADER(node)
#define REWRITE_NODE(node)
#define UPDATE_COUNTERS_IN_HEADER(meta, valid, free)
#define GET_NODES_COUNT(node, valid, free)
#define IS_NODE_EMPTY(node)
#define IS_META_HEADER(node)   ( node->prev == HEADER_INODE_IDENTIFIER )
#define IS_META_HEADER_FOR(node, meta)   ( IS_META_HEADER ( node ) && ( node->file == meta ) )

Ridefinizioni di tipo (typedefs)

typedef int(*) EvaluationCallback (void *, void *, int)

Funzioni

HyppoNode * get_node ()
int compare_char (void *first, void *second, int dim)
int compare_ushort (void *first, void *second, int dim)
int compare_short (void *first, void *second, int dim)
int compare_uint (void *first, void *second, int dim)
int compare_int (void *first, void *second, int dim)
int compare_double (void *first, void *second, int dim)
int compare_float (void *first, void *second, int dim)
int compare_ulong (void *first, void *second, int dim)
int compare_long (void *first, void *second, int dim)
int compare_ullong (void *first, void *second, int dim)
int compare_llong (void *first, void *second, int dim)
int compare_wchar (void *first, void *second, int dim)
int compare_string (void *first, void *second, int dim)
int compare_wstring (void *first, void *second, int dim)
EvaluationCallback get_evaluation_callback (UINT64 meta)
void add_in_opened_file (UINT64 fileid, unsigned long desc)
UINT64 look_into_opened_files (unsigned long desc)
void remove_from_opened_file (unsigned long desc)
int go_to_start_of_array (UINT64 meta)
int go_to_end_of_array (UINT64 meta)
UINT64 search_file_by_meta (char *data, UINT64 meta, int size)
void add_node_here (HyppoNode *node)
UINT64 get_real_path (const char *path)
int check_meta (UINT64 fileid, UINT64 metaid, HyppoNode *node)
int reconstruct_file (UINT64 fileid, UINT64 array[], UINT64 size, UINT64 max)
int convert_string_to_value (int type, char *string, void *value)
int convert_value_to_string (int type, void *value, char *string, int size)
void add_sorted_node_special (UINT64 meta, char *value, int size, UINT64 file, UINT64 prev, UINT64 next)
void add_sorted_node (UINT64 meta, char *value, int size, UINT64 file, UINT64 prev, UINT64 next, gboolean exists)
int setattr (UINT64 fileid, UINT64 metaid, const char *value, size_t size, int flags)
int getattr (UINT64 fileid, UINT64 metaid, char *value, size_t size)
int distruggi_nodo (UINT64 metaid, UINT64 fileid)
int delattr (UINT64 fileid, UINT64 metaid)
void init_file_now (UINT64 fileid, mode_t privileges, char *name)
int prepare_for_xattr (const char *path, const char *meta, UINT64 *fileid, UINT64 *metaid)
void fake_stat_for_dir (struct stat *fake)
int get_stat_by_id (UINT64 id, struct stat *fake)
char jump_trailing_spaces (char *string, int *index)
else if (AllMetadata[st[numel].meta].type &META_TYPE_STRING||AllMetadata[st[numel].meta].type &META_TYPE_WSTRING)
int hyppo_listxattr (const char *path, char *list, size_t size)
int hyppo_removexattr (const char *path, const char *name)
int hyppo_open (const char *path, struct fuse_file_info *desc)
int hyppo_read (const char *path, char *data, size_t size, off_t offset, struct fuse_file_info *desc)
int hyppo_write (const char *path, const char *data, size_t dim, off_t where, struct fuse_file_info *desc)
int hyppo_unlink (const char *path)
int hyppo_flush (const char *path, struct fuse_file_info *desc)
int hyppo_release (const char *path, struct fuse_file_info *desc)
int hyppo_fsync (const char *path, int datasync, struct fuse_file_info *desc)
int hyppo_getattr (const char *path, struct stat *ret)
int hyppo_mknod (const char *path, mode_t privileges, dev_t device)
int hyppo_rename (const char *old, const char *new)
int hyppo_chmod (const char *path, mode_t privileges)
int hyppo_chown (const char *path, uid_t user, gid_t group)
int hyppo_truncate (const char *path, off_t dimension)
int hyppo_utime (const char *path, struct utimbuf *new_time)
int hyppo_access (const char *path, int mask)
int hyppo_create (const char *path, mode_t privileges, struct fuse_file_info *desc)
int hyppo_ftruncate (const char *path, off_t where, struct fuse_file_info *desc)
int hyppo_fgetattr (const char *path, struct stat *ret, struct fuse_file_info *desc)
int hyppo_mkdir (const char *path, mode_t privileges)
int hyppo_opendir (const char *path, struct fuse_file_info *desc)
int hyppo_readdir (const char *path, void *data, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *desc)
int hyppo_rmdir (const char *path)
int hyppo_releasedir (const char *path, struct fuse_file_info *desc)
int hyppo_fsyncdir (const char *path, int flags, struct fuse_file_info *desc)
void * hyppo_init ()
void hyppo_destroy (void *useless)
int hyppo_statfs (const char *path, struct statvfs *to_ret)
int main (int argc, char **argv)

Variabili

HyppoSB HyppoSuperBlock
StateDesc Current
HyppoNodeC * ReadingNodesCache [100]
FILE * HyppoFileSystem
GSList * OpenFilesStack
static struct fuse_operations hyppo_ops

Documentazione delle definizioni

 
#define BLOCK_BACK (  ) 

Valore:

{                                                                       \
        fseeko ( HyppoFileSystem, ( hyppo_off_t ) ( ftello ( HyppoFileSystem ) - sizeof ( HyppoNode ) ), SEEK_SET );    \
}
Macro che permette di tornare un nodo indietro durante il percorrimento del file di Hyppocampus

 
#define FORWARD_BLOCK (  ) 

Valore:

{                                                                       \
        fseeko ( HyppoFileSystem, ( hyppo_off_t ) ( ftello ( HyppoFileSystem ) + sizeof ( HyppoNode ) ), SEEK_SET );    \
}
Macro che permette di andare un nodo avanti durante il percorrimento del file di Hyppocampus

#define JUMP_NEXT_HEADER ( node   ) 

Valore:

{                                                                                                               \
        if ( !IS_META_HEADER ( node ) ) {                                                                                                               \
                printf ( "Error: looking for header, node found\n" );                                                                                   \
                exit ( -1 );                                                                                                                            \
        }                                                                                                                                               \
                                                                                                                                                        \
        fseeko ( HyppoFileSystem, ( hyppo_off_t ) ( ftello ( HyppoFileSystem ) + ( sizeof ( HyppoNode ) * *( node->value ) ) ), SEEK_SET );                     \
        fseeko ( HyppoFileSystem, ( hyppo_off_t ) ( ftello ( HyppoFileSystem ) + ( sizeof ( HyppoNode ) * node->value [ FREE_BLOCKS_OFFSET ] ) ), SEEK_SET );   \
}
Macro usata per saltare da un header ad un'altro con un unico seek. Il parametro passato deve essere obbligatoriamente un header di array

#define REWRITE_NODE ( node   ) 

Valore:

{                                                       \
        DBG ( "REWRITE_NODE +" );                                                               \
        BLOCK_BACK ();                                                                          \
        fwrite ( node, sizeof ( HyppoNode ), 1, HyppoFileSystem );                              \
        DBG ( "REWRITE_NODE -" );                                                               \
}
Torna un blocco indietro all'interno del file di Hyppocampus e lo riscrive: usato fondamentalmente per sostituire blocchi

#define UPDATE_COUNTERS_IN_HEADER ( meta,
valid,
free   ) 

Valore:

{                                               \
        DBG ( "UPDATE_COUNTERS_IN_HEADER +" );                                                          \
        HyppoNode *node;                                                                                \
                                                                                                        \
        go_to_start_of_array ( meta );                                                                  \
        node = get_node ();                                                                             \
        *( node->value ) = valid;                                                                       \
        node->value [ FREE_BLOCKS_OFFSET ] = free;                                                      \
        DBG ( "%llu = valid = %llu / free = %llu", meta, ( unsigned long long ) *( node->value ),       \
              ( unsigned long long ) node->value [ FREE_BLOCKS_OFFSET ] );                              \
        REWRITE_NODE ( node );                                                                          \
        DBG ( "UPDATE_COUNTERS_IN_HEADER -" );                                                          \
}
Salta all'header del metadato desiderato ed aggiorna i contatori dei nodi occupati e di quelli liberi secondo i valori passati esplicitamente. Non e' necessario trovarsi in prossimita' dell'header dell'array per il metadato

#define GET_NODES_COUNT ( node,
valid,
free   ) 

Valore:

{                                       \
        if ( !IS_META_HEADER ( node ) ) {                                               \
                printf ( "Error: looking for header, node found\n" );                   \
                exit ( -1 );                                                            \
        }                                                                               \
                                                                                        \
        valid = ( unsigned long long ) *( node->value );                                \
        free = ( unsigned long long ) node->value [ FREE_BLOCKS_OFFSET ];               \
}
Legge l'header del metadato desiderato (passato come primo parametro della macro) i valori relativi al numero di nodi occupati e di nodi liberi nell'array designato

#define IS_NODE_EMPTY ( node   ) 

Valore:

( node->prev == EMPTY_INODE_IDENTIFIER &&       \
                                          node->file == EMPTY_INODE_IDENTIFIER &&       \
                                          node->next == EMPTY_INODE_IDENTIFIER )
Usata come espressione condizionale, TRUE se il nodo passato come parametro e' un nodo vuoto

#define IS_META_HEADER ( node   )     ( node->prev == HEADER_INODE_IDENTIFIER )

Usata come espressione condizionale, TRUE se il nodo passato come parametro e' header di un metadato

#define IS_META_HEADER_FOR ( node,
meta   )     ( IS_META_HEADER ( node ) && ( node->file == meta ) )

Usata come espressione condizionale, TRUE se il nodo passato come parametro e' header del metadato esplicitato nel secondo parametro

Documentazione delle ridefinizioni di tipo (typedefs)

typedef int( *) EvaluationCallback(void *, void *, int)

Documentazione delle funzioni

HyppoNode* get_node (  ) 

Solo per uso interno.

Legge dal file d Hyppocampus il nodo presso cui si trova l'indice di scorrimento, facendo avanzare di sizeof(HyppoNode) il cursore

Restituisce:
Il puntatore alla copia cache del nodo letto. Non liberare dalla memoria tale puntatore

Da fare:
Finire di mettere a posto la cache affinche' lavori proprio come una cache...

Da fare:
Sarebbe opportuno trovare un modo migliore per shiftare l'array della cache verso il basso, anziche' copiarlo un elemento alla volta. Ho provato memmove() ma il risultato non e' quello sperato, probabilmente bisogna castare diversamente i puntatori

int compare_char ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra char

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_ushort ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra unsigned short

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_short ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra short

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_uint ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra unsigned int

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_int ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra int

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_double ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra double

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_float ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra float

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_ulong ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra unsigned long

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_long ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra long

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_ullong ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra unsigned long long

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_llong ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra long long

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_wchar ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra wchar

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_string ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra stringhe

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

int compare_wstring ( void *  first,
void *  second,
int  dim 
)

Solo per uso interno.

Funzione di comparazione tra stringhe wchar

Parametri:
first Primo valore da confrontare
second Secondo valore da confrontare
dim Dimensione del primo valore
Restituisce:
minore di 0 se first viene prima di second, maggiore di 0 se first viene dopo second, uguale a 0 se first e second sono uguali

EvaluationCallback get_evaluation_callback ( UINT64  meta  ) 

Solo per uso interno.

Poiche' per ogni metadato i valori sono conservati in un formato particolare (a volte come stringhe, a volte come interi...), questa funzione restituisce il puntatore alla funzione piu' adatta a valutare la differenza tra due valori assegnati ad un certo metadato

Parametri:
meta ID del metadato per cui ci sono valori da confrontare
Restituisce:
Puntatore alla funzione adatta per la valutazione dei valori assegnati al metadato desiderato

void add_in_opened_file ( UINT64  fileid,
unsigned long  desc 
)

Solo per uso interno.

Per aggiungere un file descriptor nella lista interna dei files aperti

Parametri:
fileid ID del file aperto
desc File descriptor associato al file

UINT64 look_into_opened_files ( unsigned long  desc  ) 

Solo per uso interno.

Funzione usata per rintracciare un file descriptor tra quelli aperti e tracciati

Parametri:
desc File descriptor da cercare
Restituisce:
Identificativo del file associato al descrittore, o 0 se non viene trovato

void remove_from_opened_file ( unsigned long  desc  ) 

Solo per uso interno.

Rimuove un file descriptor dalla lista interna

Parametri:
desc File descriptor da rimuovere

int go_to_start_of_array ( UINT64  meta  ) 

Solo per uso interno.

Porta il cursore di spostamento nel file Hyppocampus all'inizio dell'array (ovvero: prima del relativo header) dedicato al metadato desiderato

Parametri:
meta Il metadato presso cui ci si deve spostare
Restituisce:
1 se lo spostamento e' andato a buon fine. Nella maggior parte dei casi, in situazione di errore provoca una uscita dall'applicazione

int go_to_end_of_array ( UINT64  meta  ) 

Solo per uso interno.

Porta il cursore di spostamento nel file Hyppocampus alla fine dell'array (ovvero: prima dell'ultimo nodo contenuto nell'array stesso) dedicato al metadato desiderato

Parametri:
meta Il metadato alla fine del quale ci si deve posizionare
Restituisce:
1 se lo spostamento e' andato a buon fine, 0 altrimenti

UINT64 search_file_by_meta ( char *  data,
UINT64  meta,
int  size 
)

Solo per uso interno.

Cerca il primo file cui corrisponde un certo metadato con un certo valore

Parametri:
data Il valore che deve assumere il valore del metadato per matchare la ricerca
meta Il metadato entro cui cercare
size Dimensione del valore in "data"
Restituisce:
L'ID del primo file per cui e' stato definito il metadato esplicitato col valore desiderato, o 0 se nessun file viene trovato

Da fare:
Gestire la situazione di overflow del contenuto del nodo e reperire dunque il vero valore di "value" nell'apposita raw area

void add_node_here ( HyppoNode *  node  ) 

Solo per uso interno.

Inserisce un nodo all'interno del file di Hyppocampus presso la posizione corrente del cursore di spostamento, shiftando tutti i blocchi che lo seguono fino al primo nodo vuoto incontrato

Parametri:
node Il nodo da inserire nel file

UINT64 get_real_path ( const char *  path  ) 

Solo per uso interno.

Data una path avanzata al filesystem cerca il file corrispondente. Vengono considerati validi sia i valori numerici stampati all'interno della stringa "path", interpretati come ID da cercare, sia le stringhe, considerate come nomi di files o directory

Parametri:
path La path logica del file che si desidera
Restituisce:
L'ID del file trovato, se trovato, o < 0 altrimenti. In tal caso. errno e' settata a ENOENT
Avvertimento:
E' sconsigliabile passare in "path" il nome del file che si desidera: in Hyppocampus possono esistere piu' files con lo stesso nome, identificati univocamente solo per mezzo dell'ID associato in fase di creazione

int check_meta ( UINT64  fileid,
UINT64  metaid,
HyppoNode *  node 
)

Solo per uso interno.

Preleva il nodo del metadato indicato associato al file esplicitato

Parametri:
fileid ID del file cui il metadato appartiene
metaid ID del metadato da cercare
node Puntatore ad un HyppoNode che verra' riempito col nodo letto
Restituisce:
1 se l'operazione va a buon fine, 0 altrimenti. In caso di errore il contenuto di "node" non e' valido

int reconstruct_file ( UINT64  fileid,
UINT64  array[],
UINT64  size,
UINT64  max 
)

Solo per uso interno.

Ricostruisce la lista di metadati associati ad un file

Parametri:
fileid ID del file di cui si vogliono reperire i metadati associati
array Array che verra' riempito con gli identificativi dei tipi di metadato riscontrati per il file desiderato
size Numero di elementi presenti in "array"
max Identificativo dell'ultimo metadato di cui si vuole avere notifica: non appena la ricerca si imbatte in un identificativo >= di "max", la ricerca si interrompe e la funzione ritorna. Se si desiderano recuperare tutti i metadati associati al file, settare questo parametro a 0
Restituisce:
1 se la ricerca va a buon fine, 0 in caso di errore, e -1 se "size" e' minore del numero di metadati allegati al file selezionato e l'array "array" e' insufficiente per contenerli tutti

Tratto il primo nodo della lista in maniera particolare, in modo da non dover scrivere regole complesse per la condizione del ciclo di iterazione

int convert_string_to_value ( int  type,
char *  string,
void *  value 
)

Solo per uso interno.

Converte una stringa in un valore adatto per essere conservato nel filesystem

Parametri:
type Tipo di valore ammesso per il metadato di destinazione
string Formato ASCII del valore
value Formato finale del valore
Restituisce:
La dimensione del formato finale del valore
Vedi anche:
convert_value_to_string()

Da fare:
Conversione da stringa a wchar_t

Conversione da stringa a struttura

Conversione da stringa a enum

Da fare:
Conversione da stringa a wchar_t*

int convert_value_to_string ( int  type,
void *  value,
char *  string,
int  size 
)

Solo per uso interno.

Converte un valore dalla sua forma originaria in una stringa. Cio' e' necessario perche' la API di interfaccia al filesystem si basa interamente su stringhe, mentre nel filesystem i valori sono conservati in base alla loro natura (int, long, char*...)

Parametri:
type Tipo di valore del metadato in esame
value Puntatore al valore originario, cosi' come estratto dal filesystem
string Stringa da riempire con la forma ASCII del valore
size Dimensione della stringa "string"
Restituisce:
Numero di bytes scritti in "string"

Da fare:
Convertire il carattere UTF-8 in stringa

Da fare:
Convertire la stringa UTF-8 in stringa

void add_sorted_node_special ( UINT64  meta,
char *  value,
int  size,
UINT64  file,
UINT64  prev,
UINT64  next 
)

Solo per uso interno.

Inserisce un nuovo metadato nella tabella complessiva, ma senza aggiornare il resto del file e i "puntatori" interni

Parametri:
meta Identificativo del nuovo metadato
value Valore allegato al metadato
size Dimensione del valore in "value"
file File cui il metadato e' associato
prev Identificativo del metadato che precede il nuovo nella lista di attributi per il file
next Identificativo del metadato che segue il nuovo nella lista di attributi per il file

void add_sorted_node ( UINT64  meta,
char *  value,
int  size,
UINT64  file,
UINT64  prev,
UINT64  next,
gboolean  exists 
)

Solo per uso interno.

Come add_sorted_node_special(), ma permette di inserire il nuovo blocco non solo fisicamente (scrivendolo sul file) ma anche logicamente, inserendolo all'interno della struttura logica di liste doppiamente linkate che descrivono i singoli files

Parametri:
meta Identificativo del nuovo metadato
value Valore allegato al metadato
size Dimensione del valore in "value"
file File cui il metadato e' associato
prev Identificativo del metadato che precede il nuovo nella lista di attributi per il file
next Identificativo del metadato che segue il nuovo nella lista di attributi per il file
exists TRUE se il nodo esiste gia' e si invoca questa funzione solo per aggiornarlo con un nuovo valore, FALSE se il nodo va inserito ex-novo
Da fare:
Verificare prima dell'inserimento se il tipo di metadato esiste gia' per il file definito

int setattr ( UINT64  fileid,
UINT64  metaid,
const char *  value,
size_t  size,
int  flags 
)

Solo per uso interno.

Setta un attributo esteso per un file, aggiungendolo alla struttura globale o aggiornando i dati esistenti in base al valore dell'ultimo parametro

Parametri:
fileid Identificativo del file per cui agire
metaid Identificativo del tipo di metadato da aggiungere / sostituire
value Valore assunto dal metadato per il file selezionato
size Dimensione di "value"
flags Maschera che definisce il comportamento della funzione, valgono gli stessi valori che vengono passati come ultimo parametro di hyppo_setxattr()
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file richiesto non esiste
  • EEXIST : e' stata avanzata la richiesta con il flag XATTR_CREATE, ma il metadato gia' esiste
  • ENOATTR : e' stata avanzata la richiesta con il flag XATTR_REPLACE, ma il metadato non esiste
Vedi anche:
hyppo_setxattr()

int getattr ( UINT64  fileid,
UINT64  metaid,
char *  value,
size_t  size 
)

Solo per uso interno.

Preleva un metadato dalla struttura globale

Parametri:
fileid Identificativo del file da cui prelevare il metadato
metaid Identificativo del metadato da estrarre per il file
value Area di memoria che verra' riempita col valore assunto per il metadato selezionato
size Dimensione di allocazione di "value"
Restituisce:
La dimensione del valore del metadato cercato, o < 0 in caso di errore. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file richiesto non esiste
  • ERANGE : la dimensione del buffer atto ad ospitare il valore assunto dal metadato non e' sufficiente ad ospitare suddetto valore
Vedi anche:
hyppo_getxattr()

Da fare:
Non viene ancora contemplato il tipo META_TYPE_STRUCT

Non viene ancora contemplato il tipo META_TYPE_ENUM

int distruggi_nodo ( UINT64  metaid,
UINT64  fileid 
)

Solo per uso interno.

Elimina un nodo dal file Hyppocampus di riferimento, sovrascrivendolo con un nodo vuoto (zero-filled).

Parametri:
metaid Identificativo del metadato da eliminare
fileid Identificativo del file da cui rimuovere il metadato
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOATTR : il nodo di cui e' stata richiesta la cancellazione non esiste
Avvertimento:
Questa funzione, come diverse altre, funziona solo sotto la precondizione che non esistono piu' di una istanza del metadato cercato per un dato file: ricordarsene quando sara' il momento di aggiungere la possibilita' di aggiungere piu' valori ad uno stesso metadato e allo stesso file

Da fare:
Aggiornare anche la copia cache del nodo appena rimosso!

int delattr ( UINT64  fileid,
UINT64  metaid 
)

Solo per uso interno.

Rimuove un metadato precedentemente assegnato ad un file

Parametri:
fileid Identificativo del file da cui rimuovere il metadato
metaid Identificativo del metadato da eliminare
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file richiesto non esiste
  • ENOATTR : il metadato di cui e' stata richiesta la rimozione non esiste
  • distruggi_nodo()

Bug:
Qui rischia di schiantarsi qualora si voglia rimuovere l'ultimo metadato della lista, provvedere a correggere

void init_file_now ( UINT64  fileid,
mode_t  privileges,
char *  name 
)

Solo per uso interno.

Inizializza un nuovo file, appena creato, inizializzandone i metadati fondamentali

Parametri:
fileid ID del nuovo file appena creato. Deve essere univoco all'interno del sistema e non viene qui effettuato alcun controllo sulla sua unicita'
privileges Privilegi di accesso al file. Sono definiti a priori dalla funzione effettiva di creazione di nuovi files, dipendono dall'applicazione in userspace che effettua la richiesta
name Nome assegnato al nuovo file. Non deve essere necessariamente univoco

int prepare_for_xattr ( const char *  path,
const char *  meta,
UINT64 *  fileid,
UINT64 *  metaid 
)

Solo per uso interno.

A discapito del nome, la funzione non fa altro che convertire le rappresentazioni ASCII di un file e di un metadato nelle rappresentazioni puramente numeriche: il path del file diviene un ID, ed altrettanto la stringa che descrive un metadato

Parametri:
path Path del file di cui manipolare i metadati
meta Metadato desiderato, espresso in forma di stringa. Sono ammesse solo rappresentazioni numeriche dei metadati, se la stringa non contiene un numero la funzione torna con un errore
fileid Puntatore che verra' settato all'ID del file richiesto
metaid Puntatore che verra' settato al valore numerico binario del metadato richiesto
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • EINVAL : e' stato sottoposto un metadato espresso non in forma puramente numerica, che e' l'unico ammesso a questo livello
  • ENOENT : il file richiesto non esiste

Da fare:
Rispettare le classi di attributi estesi

void fake_stat_for_dir ( struct stat *  fake  ) 

Solo per uso interno.

Funzione destinata a sparire qualora si definisca il criterio di manipolazione delle directory e delle pseudo-directory in Hyppocampus: attualmente viene usata ogniqualvolta vengono richieste le informazioni fondamentali di una cartella (o di una query SQL, che viene vista come una cartella), e fornisce un set di dati sempre uguali e settati a priori

Parametri:
fake La struttura stat da riempire con le informazioni fasulle

int get_stat_by_id ( UINT64  id,
struct stat *  fake 
)

Solo per uso interno.

Funzione di comodo che riempie una struttura di tipo stat con i valori recuperati dal filesystem

Parametri:
id Identificativo del file di cui si vogliono raccogliere i dati fondamentali
fake Struttura che verra' riempita con i valori raccolti all'interno del filesystem
Restituisce:
1 in caso di successo, se sono stati recuperati tutti i dati necessari a compilare la struttura di stat, 0 altrimenti

char jump_trailing_spaces ( char *  string,
int *  index 
) [inline]

Solo per uso interno.

Funzioncina usata per saltare gli spazi non significativi all'interno della query

Parametri:
string Stringa da elaborare
index Indice da cui partire per saltare gli spazi
Restituisce:
Il primo carattere diverso da uno spazio trovato nella stringa

else if ( AllMetadata.meta].type &META_TYPE_STRING||AllMetadata.meta].type &  META_TYPE_WSTRING[st[numel][st[numel]  ) 

int hyppo_listxattr ( const char *  path,
char *  list,
size_t  size 
)

Permette di prelevare la lista di metadati assegnati ad un file

Parametri:
path Path del file di cui recuperare la lista di metadati
list Stringa che verra' riempita con i nomi dei metadati assegnati al file, separati da '\0'
size Dimensione massima della stringa in "list"
Restituisce:
il numero di caratteri scritti in "list" in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file selezionato non esiste
  • ENOEXEC : non e' possibile recuperare la lista di metadati
  • ERANGE : la stringa "list" non e' sufficiente a contenere tutti i metadati assegnati al file

int hyppo_removexattr ( const char *  path,
const char *  name 
)

Rimuove un metadato assegnato ad un file

Parametri:
path Path del file da cui rimuovere un metadato
name Nome del metadato da rimuovere
Restituisce:
- prepare_for_xattr()

int hyppo_open ( const char *  path,
struct fuse_file_info *  desc 
)

Apre un file sul filesystem e ne restituisce il descrittore

Parametri:
path Path del file da aprire
desc File descriptor interno a FUSE
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file da aprire non esiste

int hyppo_read ( const char *  path,
char *  data,
size_t  size,
off_t  offset,
struct fuse_file_info *  desc 
)

Parametri:
path Path del file da leggere
data Buffer da riempire con i dati letti
size Dimensione del buffer da leggere
offset Indice da cui iniziare a leggere
desc File descriptor interno a FUSE
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • EBADF : il file descriptor in "desc" non e' valido
  • pread(2)

int hyppo_write ( const char *  path,
const char *  data,
size_t  dim,
off_t  where,
struct fuse_file_info *  desc 
)

Scrive un buffer di dati in un file

Parametri:
path Path del file in cui andare a scrivere
data Buffer dei dati da scrivere nel file
dim Dimensione del buffer "data"
where Indice del punto in cui iniziare a scrivere
desc File descriptor interno a FUSE
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • EBADF : il file descriptor in "desc" non e' valido
  • EIO : errore durante l'aggiornamento del valore che conserva la dimensione corrente del file
  • pwrite(2)

int hyppo_unlink ( const char *  path  ) 

Rimuove un file dal filesystem

Parametri:
path Path del file da rimuovere
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file d testare non esiste

int hyppo_flush ( const char *  path,
struct fuse_file_info *  desc 
)

Esegue un flush su un file precedentemente aperto

Parametri:
path Path del file di cui salvare lo stato
desc File descriptor interno a FUSE
Restituisce:
fflush(3)
Da fare:
Testare se path == NULL e, nel caso, effetture il flush su tutti i files aperti e tenuti nella lista interna

int hyppo_release ( const char *  path,
struct fuse_file_info *  desc 
)

Chiude un file precedentemente aperto, togliendo il suo file descriptor dalla lista di quelli validi

Parametri:
path Path del file da rilasciare
desc File descriptor interno a FUSE
Restituisce:
Senpre 0

int hyppo_fsync ( const char *  path,
int  datasync,
struct fuse_file_info *  desc 
)

Parametri:
path 
datasync 
desc 
Restituisce:
Da fare:
Da implementare

int hyppo_getattr ( const char *  path,
struct stat *  ret 
)

Preleva le informazioni essenziali relative ad un file

Parametri:
path Path del file di cui prelevare i dati
ret Struttura di tipo struct stat che verra' compilata con le informazioni fondamentali relative al file
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file d testare non esiste

Se la path cercata e' solo "/" sono state richieste le proprieta' della root del filesystem Hyppocampus, dunque si riempie la struttura di ritorno con dati abbastanza aleatori. Altrimenti, la stringa viene trattata in modo particolare:

int hyppo_mknod ( const char *  path,
mode_t  privileges,
dev_t  device 
)

Parametri:
path 
privileges 
device 
Restituisce:
Da fare:
Da implementare

int hyppo_rename ( const char *  old,
const char *  new 
)

Rinomina un file

Parametri:
old Vecchio nome del file
new Nuovo nome del file
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file da modificare non esiste
  • setattr()

int hyppo_chmod ( const char *  path,
mode_t  privileges 
)

Parametri:
path Path del file cui cambiare la modalita' di accesso
privileges Nuova maschera dei permessi da applicare
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file da modificare non esiste
  • setattr()

Da fare:
Eseguire un rollback dei dati sul filesystem reale qualora la modifica del database fallisse

int hyppo_chown ( const char *  path,
uid_t  user,
gid_t  group 
)

Cambia l'utente ed il gruppo proprietario di un file

Parametri:
path Path del file di cui cambiare il proprietario
user Nuovo utente proprietario
group Nuovo gruppo proprietario
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file da modificare non esiste
  • setattr()

Da fare:
Eseguire un rollback dei dati sul filesystem reale qualora la modifica del database fallisse

int hyppo_truncate ( const char *  path,
off_t  dimension 
)

Taglia il contenuto di un file a partire dalla dimensione specificata

Parametri:
path Path del file da troncare
dimension Indice da cui iniziare a tagliare il contenuto del file
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file da modificare non esiste
  • truncate(2)

Da fare:
Aggiornare il valore della dimensione all'interno del database

int hyppo_utime ( const char *  path,
struct utimbuf *  new_time 
)

Permette di modificare la data dell'ultimo accesso e dell'ultima modifica di un file

Parametri:
path Path del file di cui modificare la data
new_time Struttura che contiene i nuovi valori da assegnare alla data di accesso e di modifica
Restituisce:
setattr()

Da fare:
Eseguire un rollback dei dati sul filesystem reale qualora la modifica del database fallisse

int hyppo_access ( const char *  path,
int  mask 
)

Verifica la modalita' di accesso di un file

Parametri:
path Path del file da verificare
mask Maschera di attributi da testare sul file. Cfr. access (2)
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • ENOENT : il file d testare non esiste
  • EACCESS : uno degli attributi richiesti non e' settato
  • getattr()

int hyppo_create ( const char *  path,
mode_t  privileges,
struct fuse_file_info *  desc 
)

Crea ed apre un nuovo file

Parametri:
path Path del nuovo file da creare
privileges Privilegi con cui creare il file
desc Struttura che contiene il file descriptor che si riferisce al file appena creato ed aperto
Restituisce:
hyppo_open()

int hyppo_ftruncate ( const char *  path,
off_t  where,
struct fuse_file_info *  desc 
)

Taglia il contenuto di un file alla dimensione specificata

Parametri:
path Path del file da troncare
where Offset da cui partire a tagliare il contenuto
desc Non usato
Restituisce:
hyppo_truncate()

Da fare:
Verificare se ftruncate e truncate sono davvero compatibili e scambiabili...

int hyppo_fgetattr ( const char *  path,
struct stat *  ret,
struct fuse_file_info *  desc 
)

Preleva le informazioni primarie relative ad un dato file

Parametri:
path Path del file di cui prelevare le informazioni
ret Struttura di tipo struct stat che verra' compilata con le informazioni principali relative al file richiesto
desc Non usato
Restituisce:
hyppo_getattr()

Da fare:
Verificare se fgetattr e getattr sono davvero compatibili e scambiabili...

int hyppo_mkdir ( const char *  path,
mode_t  privileges 
)

Parametri:
path 
privileges 
Restituisce:
Da fare:
Da implementare

int hyppo_opendir ( const char *  path,
struct fuse_file_info *  desc 
)

Parametri:
path 
desc 
Restituisce:
Da fare:
Da implementare

int hyppo_readdir ( const char *  path,
void *  data,
fuse_fill_dir_t  filler,
off_t  offset,
struct fuse_file_info *  desc 
)

Parametri:
path Path della cartella da leggere. Se viene sottoposta una query SQL, la si trova qui, esattamente come se fosse una directory come le altre
data Buffer che viene riempito con le informazioni sui files reperiti nella cartella
filler Callback di riempimento del buffer "data"
offset Indice da cui partire con la lettura dei files
desc Non usato
Restituisce:
0 in caso di successo, -1 altrimenti. In caso di errore, la variabile errno viene settata secondo i seguenti valori:
  • EBADF : la query passata non e' valida

Ricordarsi che "path" inizia sempre con '/'

La funzione prevede la richiesta dei files contenuti nella root del filesystem...

Da fare:
Per ignote ragioni, da un giorno all'altro la funzione readdir si rifiuta di accettare come nome del file la stringa che rappresenta l'ID del file paddata con HYPPO_MAX_REAL_NAMELEN zeri. Cio' non porta particolari problemi, ma e' sgradevole: vedere da cosa puo' dipendere e risolvere il problema (probabilmente dovuto ad un conflitto con i define della libc...)

... la ricerca per path tradizionale (vengono restituiti tutti i files che sono stati creati richiedendo una data path)...

... e la ricerca SQL (vengono restituiti i files che matchano la query passata)

int hyppo_rmdir ( const char *  path  ) 

Parametri:
path 
Restituisce:
Da fare:
Da implementare

int hyppo_releasedir ( const char *  path,
struct fuse_file_info *  desc 
)

Parametri:
path 
desc 
Restituisce:
Da fare:
Da implementare

int hyppo_fsyncdir ( const char *  path,
int  flags,
struct fuse_file_info *  desc 
)

Parametri:
path 
flags 
desc 
Restituisce:
Da fare:
Da implementare

void* hyppo_init (  ) 

Funzione di inizializzazione del filesystem: provvede a verificare il file di appoggio e, se non esiste, lo crea. Qui viene allocato lo spazio per la cache (cfr. get_node() ) ed sono inizializzate le variabili usate per l'ottimizzazione degli spostamenti

Restituisce:
NULL

Da fare:
Verificare se esiste un modo "standard" di recuperare la path della home directory dell'utente

Se vuoto, il filesystem viene inizializzato con un file nominato "README". Per ora e' vuoto, ma dovrebbe contenere una breve descrizione sulle modalita' di accesso al filesystem stesso

void hyppo_destroy ( void *  useless  ) 

Funzione invocata al momento della chiusura del filesystem, libera le risorse allocate in hyppo_init()

Parametri:
useless Dichiarato solo in favore del prototipo della funzione

int hyppo_statfs ( const char *  path,
struct statvfs *  to_ret 
)

Funzione per recuperare le informazioni relative al filesystem. In realta', poiche' Hyppocampus agisce al di sopra del filesystem locale realmente installato, vengono restituite le informazioni in merito a quest'ultimo, con poche o nessuna modifica ai valori originari

Parametri:
path Path di un qualunque file che si trova nel filesystem
to_ret Puntatore ad una struttura di tipo struct statvfs che verra' compilata con i valori opportuni
Restituisce:
0 in caso di riuscita, < 0 altrimenti

Non esiste un numero massimo di caratteri che compongono il nome di un file: nel filesystem reale tutti i files sono salvati con, come nome, il loro stesso ID, mentre il nome utente viene memorizzato solo all'interno della struttura relazionale vera e propria

int main ( int  argc,
char **  argv 
)

Funzione primaria

Parametri:
argc Numero di argomenti passati all'invocazione
argv Lista degli argomenti passati
Restituisce:
0 se non ci sono errori, != 0 altrimenti

Documentazione delle variabili

HyppoSB HyppoSuperBlock

"Superblocco" del filesystem Hyppocampus: qui si trovano le informazioni minime per sapere in che modo usare il file di sistema del filesystem

StateDesc Current

Qui si trova il riassunto dell'attuale posizionamento all'interno del file di descrizione del filesystem: permette di non iniziare sempre dall'inizio del file ad ogni ricerca, ma di tenere traccia dei precedenti spostamenti. Potrebbe essere utile usare non un solo elemento ma un'intero stack di spostamenti per minimizzare le ricerche e i seek

HyppoNodeC* ReadingNodesCache[100]

Array che contiene la cache dei nodi letti dal file fisico che contiene Hyppocampus: utile per evitare qualche seek e minimizzare gli accessi a disco

FILE* HyppoFileSystem

File che ospita l'intera struttura relazionale del filesystem montato, in forma binaria

GSList* OpenFilesStack

struct fuse_operations hyppo_ops [static]

Struttura che riassume gli handler definiti per ogni operazione richiesta al modulo

Generato il Thu Aug 10 16:04:58 2006 per Hyppocampus da  doxygen 1.4.7