- El archivo del tipo 2 ya mete registros y los borra (falta fixear el emufs_ifx_borr...

- Cambios fsc.c: Implemente una funcion especifica para mi tipo2, emufs_fsc_agregar_gap la cual mete un gap dado el borrado de un registro en el .dat, y si encuentra un gap anterior Y/O posterior, hace los merges que tenga que hacer. Por ahora cuando hacer un merge y tiene que justificar el .fsc, lo hace reg por reg (leeeeentoooo), luego lo hare de a N Registros por vez, como hablaba con Luca hoy por icq...

diff --git a/emufs/fsc.c b/emufs/fsc.c
index d6ec6a02499506f99737d44c9043b7f739f93358..a94a2f1ecfde3b1399f3b135e23a427e3213ccb3 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -45,7 +45,7 @@ int emufs_fsc_crear(EMUFS* efs)
        return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT);
 }
 
-/* Agrega un registro al archivo de espacios libres. */
+/* Agrega un registro al archivo de espacio libre en bloque. */
 int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespace)
 {
        FILE *f_fsc;
@@ -66,6 +66,119 @@ int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespac
        return 0;
 }
 
+/* Agrega un GAP en el archivo de Gaps para Filetype 2 */
+int emufs_fsc_agregar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_freespace)
+{
+       FILE *f_fsc;
+       EMUFS_FSC gap_aux,gap_before,gap_after,gap_new;
+       char name_f_fsc[255];
+       EMUFS_REG_ID n_gap_before = 0, n_gap_after = 0;
+       unsigned long n_source,n_destination,n_filesize,n_reg_count = 0,n_moved = 0;
+       
+       
+       strcpy(name_f_fsc,emu->nombre);
+       strcat(name_f_fsc, EMUFS_FSC_EXT);
+       
+       gap_before.n_marker = -1;
+       gap_after.n_marker = -1;
+       
+       /* Busco si hay un GAP por delante y/o por detras del que se esta por crear */
+       /* para en dicho caso realizar un merge! */
+       if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; 
+       while ( !feof(f_fsc) ){
+               if ( fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
+               
+               /* Chequeo si es un gap justo anterior al nuestro */
+               if (gap_aux.n_marker+gap_aux.n_freespace == n_marker) {
+                       gap_before.n_marker = gap_aux.n_marker;
+                       gap_before.n_freespace = gap_aux.n_freespace;
+                       n_gap_before = n_reg_count;
+               }
+               
+               /* Chequeo si es un gap justo posterior al nuestro */           
+               if (gap_aux.n_marker == n_marker+n_freespace) {
+                       gap_after.n_marker = gap_aux.n_marker;
+                       gap_after.n_freespace = gap_aux.n_freespace;
+                       n_gap_after = n_reg_count;
+               }               
+               n_reg_count += 1;
+       }
+       
+       /* Si no encontre gaps ni por delante ni por detras */
+       if ((gap_before.n_marker == -1) && (gap_after.n_marker == -1)) {
+               /* Lo guardo en el archivo al final */
+               gap_new.n_marker = n_marker;
+               gap_new.n_freespace = n_freespace;
+               fseek(f_fsc,0,SEEK_END);
+               fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+               fclose(f_fsc);          
+       }
+       
+       /* Si encuentro un GAP Justo por delante pero no por detras */
+       if ((gap_before.n_marker != -1) && (gap_after.n_marker == -1))
+       {
+         printf("fsc.c >> Found GAP justo por Delante pero no por Detras!!\n");
+         printf("fsc.c >> Gap found is reg number %lu in .fsc file\n",n_gap_before);
+         /* Me posiciono en el registro que indica dicho gap y lo reescribo con */
+         /* la suma de los espacios libres */    
+         fseek(f_fsc,sizeof(EMUFS_FSC)*n_gap_before,0);
+      gap_new.n_marker = gap_before.n_marker;
+         gap_new.n_freespace = gap_before.n_freespace + n_freespace;
+         fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+         fclose(f_fsc);
+       }
+       
+       /* Si encuentro un GAP Justo por detras pero no por delante */
+       if ((gap_before.n_marker == -1) && (gap_after.n_marker != -1))
+       {
+         printf("fsc.c >> Found GAP justo por Detras pero no por Delante!!\n");
+      printf("fsc.c >> Gap found is reg number %lu in .fsc file\n",n_gap_after);               
+         /* Me posiciono en el registro que indica dicho gap y lo reescribo con */
+         /* los datos actualizados de offset y espacio */
+         fseek(f_fsc,sizeof(EMUFS_FSC)*n_gap_after,0);
+      gap_new.n_marker = gap_after.n_marker - n_freespace;
+         gap_new.n_freespace = gap_after.n_freespace + n_freespace;
+         fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+         fclose(f_fsc);
+       }
+       
+       /* Finalmente, si encuentro Justo por delante y por detras..*/
+       if ((gap_before.n_marker != -1) && (gap_after.n_marker != -1))
+       {
+         printf("fsc.c >> Found GAP justo por Delante y por Detras!!\n");
+         printf("fsc.c >> Pre Gap found is reg number %lu in .fsc file\n",n_gap_before);       
+         printf("fsc.c >> Post Gap found is reg number %lu in .fsc file\n",n_gap_after);               
+         /* Guardo el nuevo GAP que posee los tres espacios sumados */
+         fseek(f_fsc,sizeof(EMUFS_FSC)*n_gap_before,0);
+      gap_new.n_marker = gap_before.n_marker;
+         gap_new.n_freespace = gap_before.n_freespace + n_freespace + gap_after.n_freespace;
+         fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+               
+         /* Guardamos la posicion actual del fpi pues sera en donde comenzaremos */
+         /* a mover los registros a recompactar. Ademas, calculo cuantos regs mover */
+         n_destination = sizeof(EMUFS_FSC)*n_gap_after;
+         n_source = n_destination+sizeof(EMUFS_FSC); /* Salteo el gap_after! */
+         fseek(f_fsc,0,SEEK_END);
+         n_filesize = ftell(f_fsc);
+         n_reg_count = (n_filesize - n_source) / sizeof(EMUFS_FSC);
+         printf("Destination: %lu  Source: %lu  Cant Regs a Mover: %lu\n",n_destination,n_source,n_reg_count);
+               
+         /* Comienzo a mover */
+         while (n_moved < n_reg_count) {
+        fseek(f_fsc,n_source,0);
+        fread(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+               fseek(f_fsc,-sizeof(EMUFS_FSC)*2,SEEK_CUR);
+               fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc);
+               n_source += sizeof(EMUFS_FSC);          
+               ++n_moved;
+         }
+         fclose(f_fsc);
+         truncate(name_f_fsc, n_filesize - sizeof(EMUFS_FSC)); 
+       }       
+       
+    return 0;
+}
+
 /* Objetivo: Actualiza un registro de espacio libre de acorde al FType */
 int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespace)
 {

diff --git a/emufs/fsc.h b/emufs/fsc.h
index 9b54d615ccfebe464679e563e2e1c0e6ebf1af06..fad54743f261b181e0a756718a6759f6fb2335be 100644 (file)
--- a/emufs/fsc.h
+++ b/emufs/fsc.h
@@ -49,6 +49,7 @@ typedef struct emufs_fsc_t {
 
 int emufs_fsc_crear(EMUFS*);
 int emufs_fsc_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
+int emufs_fsc_agregar_gap(EMUFS *, EMUFS_OFFSET, EMUFS_FREE);
 int emufs_fsc_actualizar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE);
 EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *);
 EMUFS_FREE emufs_fsc_get_fs(EMUFS *, EMUFS_BLOCK_ID);

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index 70d889d98d509994b1ec4e6b0e12f1e7888b1170..6f05f667de94ad229cf0bae82b3303e0cce322e7 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -116,6 +116,12 @@ int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)
        printf ("tipo2.c >> About to delete Reg %lu of Size: %lu\n",n_IdReg,n_RegSize);
        emufs_tipo2_dummyfill(efs,n_RegOffset,n_RegSize);
        
+       /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
+       /* otro GAP por delante y/o por detras en caso de hayarlo. */
+       emufs_fsc_agregar_gap(efs,n_RegOffset,n_RegSize+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));
+       /* Borramos el registro del indice de posiciones relativas */
+       /*emufs_idx_borrar(efs,n_IdReg);*/
+       
        return(0);
 }
 

diff --git a/emufs/tipo2.h b/emufs/tipo2.h
index 49b8ac09eb7f8d8dee94b7265fcec876739c5938..c4085412e4eec6f0bf00bf14f78e0c8d24c815d0 100644 (file)
--- a/emufs/tipo2.h
+++ b/emufs/tipo2.h
@@ -40,6 +40,8 @@
 EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *, void *, EMUFS_REG_SIZE, int*);
 int emufs_tipo2_borrar_registro(EMUFS*, EMUFS_REG_ID);
 EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *);
+int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE *n_RegSize);
+int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos,EMUFS_REG_SIZE n_Amount);
 
 /* int emufs_tipo2_leer_registro(EMUFS *, EMUFS_REG_ID , void *, EMUFS_REG_SIZE);
    int emufs_tipo2_buscar_registro(EMUFS *, int); */

diff --git a/emufs/tipo2_main.c b/emufs/tipo2_main.c
index ba5e615cdfa289ddb89bbad68dd950ad0b4f5715..f0a521301d47f49b16c9335f8915357c7b445799 100644 (file)
--- a/emufs/tipo2_main.c
+++ b/emufs/tipo2_main.c
@@ -72,10 +72,20 @@ int main(int argc, char *argv[])
        n8 = fp->grabar_registro(fp, h, 63, &err);
 
        /* Borramos un registro del medio */
+       printf("tipo2_main.c >> Borrando registro: %lu\n",n1);
+       fp->borrar_registro(fp, n1);
+       printf("tipo2_main.c >> Borrando registro: %lu\n",n6);
+       fp->borrar_registro(fp, n6);    
+       printf("tipo2_main.c >> Borrando registro: %lu\n",n2);
+       fp->borrar_registro(fp, n2);
+       printf("tipo2_main.c >> Borrando registro: %lu\n",n8);
+       fp->borrar_registro(fp, n8);
        printf("tipo2_main.c >> Borrando registro: %lu\n",n4);
-       if (fp->borrar_registro(fp, n4) == -1)
-         printf("tipo2_main.c >> Error al Borrar Registro Nro: %lu",n4);
+       fp->borrar_registro(fp, n4);
+       printf("tipo2_main.c >> Borrando registro: %lu\n",n7);
+       fp->borrar_registro(fp, n7);    
        
+         
        /*n8 = fp->grabar_registro(fp, i, 100);
        fp->leer_registro(fp, n8, b, 100);