SFAT - La luce

Ebbene si... Dopo mille avventure, ricevimenti, e-mail e mesi insonni è arrivato anche il mio turno di vittoria.
Sono riuscito a scrivere sul disco, mantenendo la gestione dei blocchi logici le directory che tramite comando
$./sfat_mkdir
voglio creare sul disco.

Ecco il codice sicuramente buggato che ho prodotto.
Un chiaro segno di luce.
Ecco il codice:
__________________________
/**
*Funzione che permette di scrivere una nuova directory_entry sul disco.
*
*@param fs device sul quale scrivere.
* dt directory_table dalla quale prendere la directory
* entry da scrivere sul blocco.
* log blocchi nella quale e' divisa la directory table
* num_log_block numero di blocchi logici sulla quale e' divisa.
* f_ctrl struttura di controllo della FAT.
*
*@return 0 se tutto e' stato fatto correttamenet
* un codice di errore altrimenti.
*/
int writeDe(FILE *fs, directory_table * dt,int * log, int num_log_block,fat_ctrl * f_ctrl){
int result = 0;
int n_e_per_block; /*Numero di entry che ho per blocco*/
int num_entry_last_block; /*Numero di entry nell'ultimo blocco*/
int num_entry_first_blk; /*Numero di entry nel primo blocco*/
int size_entry_last_block;
int new_fat_free_block;
int remaining_size;
int pos_num_entry; /*Posizione sul disco di num_entry*/
int position; /*Variabile che mi tiene la posizione in
cui scrivere*/
int prova;
dir_entry * curr_dir;

printDt(dt);
pos_num_entry = f_ctrl->blk_base + (log[0]*f_ctrl->b_sector->block_size);
result = fseek(fs,pos_num_entry,SEEK_SET);
if(result == -1)
return ERBD;

/*Scrivo il nuovo numero di entry*/
result = fwrite(&dt->num_entry,sizeof(int),1,fs);
if(result == -1)
return EWBD;

/*Ora mi posiziono sull'ultimo blocco e guardo se ci sta'
la nuova directory entry*/
if(num_log_block == 1){
/*Se ho solo un blocco su cui e' salvata la directory table
l'ultimo blocco di memorizzazione coincide con il primo*/
num_entry_first_blk = dt->num_entry-1;
size_entry_last_block = (num_entry_first_blk * sizeof(dir_entry)) + sizeof(int);
remaining_size = f_ctrl->b_sector->block_size - size_entry_last_block - sizeof(int);
}
else{
/*Calcolo il numero di dir_entry per blocco.*/
n_e_per_block = f_ctrl->b_sector->block_size / sizeof(dir_entry);
/*Calcolo il numero di dir_entry nel primo blocco*/
num_entry_first_blk = (f_ctrl->b_sector->block_size - sizeof(int)) / sizeof(dir_entry);
/*Ottengo il numero di entry che ho nell'ultimo blocco*/
num_entry_last_block = dt->num_entry - num_entry_first_blk -
((num_log_block - 2)* n_e_per_block);

/*Calcolo la dimensione delle dir_entry nell'ultimo blocco*/
size_entry_last_block = sizeof(dir_entry) * num_entry_last_block;
/*Calcolo la dimensione che mi rimane all'interno dell'ultimo blocco*/
remaining_size = f_ctrl->b_sector->block_size - size_entry_last_block;
}

/*Controllo ci sia ancora abbastanza spazio nell'ultimo blocco di
memorizzazione*/
if(remaining_size > sizeof(dir_entry)){
/**
*-Ci posizioniamo all'ultimo blocco;
*-Ci spostiamo dopo l'ultima dir_entry;
*/
position = f_ctrl->blk_base + (log[num_log_block - 1] * f_ctrl->b_sector->block_size) + size_entry_last_block;
result = fseek(fs, position, SEEK_SET);
}
else{
/**
*Altrimenti non c'e' abbastanza spazio nel blocco corrente per
*poter inserire una nuova directory entry.
*Quindi:
*-Cerco un nuovo blocco libero nella fat
*-Aggiorno la fat con il nuovo blocco occupato
*-Mi posiziono nel nuovo blocco trovato
*/
new_fat_free_block = searchFreeBlockInFAT(f_ctrl);
result = updateFAT(f_ctrl,new_fat_free_block);

/*Mi posiziono nell'ultimo blocco*/
position = f_ctrl->blk_base + (new_fat_free_block * f_ctrl->b_sector->block_size);
result = fseek(fs,position,SEEK_SET);

}
/*Una volta che mi sono posizionato correttamente, scrivo la dir_entry*/

curr_dir = dt->table[dt->num_entry - 1];

result = fwrite(curr_dir,sizeof(dir_entry),1,fs);

fflush(fs);
if(result == -1)
return ERBD;



return result;
}
__________________________

Spero possa chiarire le idee su quello che vuol dire salvare una directory entry su un disco.