La fine di un'era.

Lo comunico su questo blog che per un po' è stato il punto di divulgazione di ciò che penso del mondo computerizzato.

Oggi rientrando a casa dall'esame di Basi di Dati vengo accolto da una telefonata. Il soggetto all'altro capo del telefono era Giovanna Persico, responsabile risorse umane di IBM italia per quanto riguarda la Liguria. Mi hanno proposto 6 mesi di corso per entrare a far parte dello staf che cura lo sviluppo del sistema operativo di casa: IBM System Z. Tempo fa ho inviato il mio CV a IBM, che già aveva i miei dati raccolti al Net & System security, con allegato il codice di due miei progetti universitari (per gli amici parseT e sfat). In breve sono piaciuto all'azienda che mi vuole formare al suo interno. Dovrò trasferirmi a Genova negli appartamenti dedicati ai giovani che seguono questo corso presso l'azienda a spese loro. Non c'è che dire l'esperienza mi rende molto eccitato e non vedo l'ora di partire.

Mi dispiace abbandonare i miei colleghi universitari che in questi anni mi sono stati vicini, ma non penso di abbandonare completamente gli studi all'università di Pisa. Solo penso verranno leggermente dilatati.

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.

Scovolemmi Team si allarga.

E' già partito il nuovo progetto Sfat che porterà alla versione 1.0 per dicembre. Il team ha un nuovo membro, Francesca alla quale diamo il benvenuto. Speriamo dia una spinta fondamentale allo sviluppo.

Nel frattempo annuncio l'inizio della stesura di un libro teso ad iniziare coloro che vogliono avvicinarsi alla programmazione, ovviamente su sistema operativo free.
Spero che il testo sia completo entro la metà del prossimo anno.

Auguro a tutti buon lavoro.