]> git.llucax.com Git - z.facultad/75.06/emufs.git/blobdiff - emufs/tipo2.c
* Agregue algunos memset para asegurar que la GUI se vea bonita (puede que alguno...
[z.facultad/75.06/emufs.git] / emufs / tipo2.c
index 7047e455f696d3d2c7b959c1c264f71ae5a58e02..2bdb6e95ebeac7a36a839e3ead10b6415de2c002 100644 (file)
 int emufs_tipo2_inicializar(EMUFS* efs)
 {
        efs->grabar_registro = emufs_tipo2_grabar_registro;           
-  efs->borrar_registro = emufs_tipo2_borrar_registro;
+    efs->borrar_registro = emufs_tipo2_borrar_registro;
        efs->leer_registro = emufs_tipo2_leer_registro;
        efs->modificar_registro = emufs_tipo2_modificar_registro;
+       efs->leer_estadisticas = emufs_tipo2_leer_estadisticas;
        
        return 0;
 }
@@ -114,7 +115,7 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE r
        if (wrt_offset == -1) {                
                
                /* Obtengo un ID libre para el registro y luego grabo a disco */
-        id_reg = emufs_idx_get_new_id(efs, err);
+               id_reg = emufs_idx_get_new_id(efs, err);
                fseek(f_data, 0, SEEK_END);
                reg_offset = ftell(f_data);
 
@@ -130,11 +131,11 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE r
        } else {
                
                /* Obtengo un ID libre para el registro y luego grabo en disco */
-        id_reg = emufs_idx_get_new_id(efs, err);
+               id_reg = emufs_idx_get_new_id(efs, err);
                reg_offset = wrt_offset;
                fseek(f_data,reg_offset,0);
                
-        /* Escribo [RegId]|[RegSize]|[RegData] */
+    /* Escribo [RegId]|[RegSize]|[RegData] */
                fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
                fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
                fwrite(ptr,reg_size,1,f_data);
@@ -205,23 +206,24 @@ int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *re
 /* Pisa con basura lo que es hasta el momento un reg en el disco para indicar su borrado (Debug Purposes Only) */
 int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount)
 {
-    FILE *f_data;
+       FILE *f_data;
        char name_f[255];
-    char *dummyfill;
+       char *dummyfill;
        char *ptr_cur;
        unsigned long fill_size,byte_count;
        
-    /* Armamos el filename del archivo de datos */
-       strcpy(name_f,efs->nombre);
+       /* Armamos el filename del archivo de datos */
+       strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");
 
-    if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
+       if ((f_data = fopen(name_f,"rb+")) == NULL) return -1; /* ERROR */
        
        /* Preparo el garbage y se lo tiro encima */
        fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
        dummyfill = (char*)malloc(fill_size);
+       memset(dummyfill, 0, fill_size);
        ptr_cur = dummyfill;
-       for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,"#",1);
+       for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,0,1);
        fseek(f_data,reg_pos,SEEK_SET);
        fwrite(dummyfill,fill_size,1,f_data);
        fclose(f_data);
@@ -230,8 +232,194 @@ int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amoun
        return (0);
 }
 
-EMUFS_REG_ID emufs_tipo2_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
+/* Realiza la actualizacin de un registro ya existente */
+EMUFS_REG_ID emufs_tipo2_modificar_registro(EMUFS *efs, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
 {
-       emufs_tipo2_borrar_registro(emu, id);
-       return emufs_tipo2_grabar_registro(emu, data, size, error);
+       emufs_tipo2_borrar_registro(efs, id);
+       return emufs_tipo2_grabar_registro(efs, data, size, error);
+}
+
+/* Recompila y devuelve ciertas estadisticas del archivo indicado */
+EMUFS_Estadisticas emufs_tipo2_leer_estadisticas(EMUFS *efs)
+{
+    EMUFS_Estadisticas stats;
+       EMUFS_REG_ID *tmp;
+       unsigned long fsc_size = 0,idx_size = 0;
+       char name_f[255];
+       FILE *file;
+
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");
+       
+       /* Inicializo las stats por si hay error somewhere */
+       stats.tam_archivo = 0;
+       stats.tam_archivo_bytes = 0;
+       stats.info_control = 0;
+       stats.media_fs = 0;
+       stats.total_fs = 0;
+       stats.max_fs = 0;
+       stats.min_fs = 0;
+       stats.cant_bloques = 0;
+       
+       /* Obtengo las stats de FSC */
+       stats.total_fs = emufs_fsc_get_total_fs(efs);
+       stats.media_fs = emufs_fsc_get_media_fs(efs);
+       emufs_fsc_get_max_min_fs(efs,&stats.min_fs,&stats.max_fs);
+       
+       /* Cant registros */
+       tmp = emufs_idx_get(efs,&stats.tam_archivo);
+       free(tmp);
+       
+       /* Size del archivo de datos */
+       if ( (file = fopen(name_f,"ab")) == NULL){
+                       PERR("No se pudo abrir el archivo");
+                       return stats;   
+       }
+       stats.tam_archivo_bytes = ftell(file);
+       fclose(file);
+
+       /* Size del archivo de Espacio Libre */ 
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,EMUFS_FSC_EXT);
+       if ( (file = fopen(name_f,"ab")) == NULL){
+           PERR("No se pudo abrir el archivo");
+               return stats;   
+       }
+       fsc_size = ftell(file);
+       fclose(file);
+       
+       /* Size del archivo Indice */   
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,EMUFS_IDX_EXT);
+       if ( (file = fopen(name_f,"ab")) == NULL){
+           PERR("No se pudo abrir el archivo");
+               return stats;   
+       }
+       idx_size = ftell(file);
+       fclose(file);
+       
+       /* Cantidad de Bytes en info de control */
+       stats.info_control = idx_size + fsc_size + sizeof(EMUFS_REG_ID)*stats.tam_archivo + sizeof(EMUFS_REG_SIZE)*stats.tam_archivo + sizeof(EMUFS_Tipo);
+       
+       return(stats);  
+}
+
+/* Recompila y devuelve ciertas estadisticas del archivo indicado */
+int emufs_tipo2_recompactar(EMUFS *efs)
+{
+       char name_fdat[255],name_ffsc[255];
+       FILE *datfile;
+       FILE *fscfile;
+       EMUFS_FSC reg1,reg2;
+       unsigned long cant_gaps = 0,mustmove_bytes = 0,source = 0,
+                                 destination = 0,datsize = 0,totalfsc = 0;
+       
+       strcpy(name_fdat,efs->nombre);
+       strcpy(name_ffsc,efs->nombre);
+       strcat(name_fdat,".dat");
+       strcat(name_ffsc,EMUFS_FSC_EXT);
+       
+       /* Obtengo el tamanio del .dat */
+       if ( (datfile = fopen(name_fdat,"rb+")) == NULL){
+                       PERR("No se pudo abrir el archivo");
+                       return -1;      
+       }
+       fseek(datfile,0,SEEK_END);
+       datsize = ftell(datfile);
+       
+       /* Obtengo la cantidad de gaps */
+       if ( (fscfile = fopen(name_ffsc,"rb")) == NULL){
+                       PERR("No se pudo abrir el archivo");
+                       return -1;      
+       }
+       fseek(fscfile,0,SEEK_END);
+       cant_gaps = ftell(fscfile)/sizeof(EMUFS_FSC);
+       
+       if (cant_gaps == 0) return 0;
+       if (cant_gaps == 1) {
+               /* Un solo gap, muevo toda la data luego del gap y trunco */
+               fseek(fscfile,0,SEEK_SET);
+               fread(&reg1,sizeof(EMUFS_FSC),1,fscfile);       
+               source = reg1.marker + reg1.freespace;
+               destination = reg1.marker;
+               mustmove_bytes = datsize - source;
+               /*printf("Para recompactar, must move: %lu bytes\n",mustmove_bytes);
+               printf("Will move from: %lu  to  %lu\n",source,destination);*/
+               emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
+       }
+       if (cant_gaps > 1)
+       {
+               /* Comienzo leyendo un gap */
+               fseek(fscfile,0,SEEK_SET);
+               fread(&reg1,sizeof(EMUFS_FSC),1,fscfile);
+               destination = reg1.marker;
+               --cant_gaps;
+               
+               while (cant_gaps > 0)
+               {
+                       /* El source siempre sera el fin del anteultimo gap leido */
+                       source = reg1.marker + reg1.freespace;
+                       /* Leemos otro gap para calcular cuanto debemos mover */
+                       fread(&reg2,sizeof(EMUFS_FSC),1,fscfile);
+                       mustmove_bytes = reg2.marker - source;
+                       /*printf("Para recompactar, must move: %lu bytes\n",mustmove_bytes);
+                       printf("Will move from: %lu  to  %lu\n",source,destination);*/
+                       emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
+                       /* Guardo el nuevo destino que es donde termino de mover */
+                       destination = ftell(datfile);
+                       /* El ultimo gap leido, pasa a ser el de referencia ahora */
+                       reg1.marker = reg2.marker;
+                       reg1.freespace = reg2.freespace;
+                       --cant_gaps;
+               }
+               
+               /* Realizo el movimiento del ultimo chunk de datos */
+               source = reg1.marker + reg1.freespace;
+               mustmove_bytes = datsize - source;
+               emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
+       }
+               
+       fclose(datfile);
+       fclose(fscfile);
+       
+       /* Trunco el dat para que no quede el espacio vacio al final */
+       totalfsc = emufs_fsc_get_total_fs(efs);
+       truncate(name_fdat,datsize - totalfsc);
+       truncate(name_ffsc,0);
+       return 0;
+}
+
+void emufs_tipo2_movedata(FILE *datfile,EMUFS_OFFSET *source, EMUFS_OFFSET *destination, EMUFS_BLOCK_SIZE mustmove_bytes)
+{
+    int chunksize = 9;
+       char *chunk = malloc(chunksize*sizeof(char));
+       unsigned long cant_chunks = 0,left_chunk = 0;
+       
+       /* Obtengo cuantos bloques de a CHUNKSIZE bytes debo mover. Si la cantidad es no entera */
+       cant_chunks = floor(mustmove_bytes/chunksize);
+       left_chunk = fmod(mustmove_bytes,chunksize);
+       
+       /*printf ("Cantidad de chunk de %i bytes movidos: %lu\n",chunksize,cant_chunks);
+       printf ("Left chunk movido fue de: %lu bytes\n",left_chunk);*/
+       
+       while(cant_chunks > 0)
+       {
+               fseek(datfile,*source,SEEK_SET);
+               fread(chunk,chunksize,1,datfile);
+               fseek(datfile,*destination,SEEK_SET);
+               fwrite(chunk,chunksize,1,datfile);
+               *source += chunksize;
+               *destination += chunksize;              
+               --cant_chunks;
+       }
+       
+       if (left_chunk > 0)
+       {
+               fseek(datfile,*source,SEEK_SET);
+               fread(chunk,left_chunk,1,datfile);
+               fseek(datfile,*destination,SEEK_SET);
+               fwrite(chunk,left_chunk,1,datfile);
+       }
+       
+       free(chunk);
 }