Last working copy del dia, utilizando latest revision del resto de los archivos

[z.facultad/75.06/emufs.git] / emufs / tipo2.c

diff --git a/emufs/tipo2.c b/emufs/tipo2.c
index e3025cbec9b96969101a940aeed2a4daab957098..d195835e054e544b7148291002bd4eba8e897b83 100644 (file)
--- a/emufs/tipo2.c
+++ b/emufs/tipo2.c
@@ -37,100 +37,172 @@
 #include "did.h"
 
 /**********************************************************************/
 #include "did.h"
 
 /**********************************************************************/

-/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr,    */
+/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr,    */

 /*                                 EMUFS_REG_SIZE n_RegSize)          */
 /* Objetivo: Grabar un registro en un archivo del Tipo 2.             */
 /*                                 EMUFS_REG_SIZE n_RegSize)          */
 /* Objetivo: Grabar un registro en un archivo del Tipo 2.             */

-/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */

 /*             void *ptr // Puntero al buffer (registro) a guardar    */
 /*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
 /**********************************************************************/
 /*             void *ptr // Puntero al buffer (registro) a guardar    */
 /*             EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion   */
 /**********************************************************************/

-EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE n_RegSize)
+EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n_RegSize, int* err)

 {
        EMUFS_REG_ID n_IdReg;
        EMUFS_FREE n_FreeSpace;
        EMUFS_OFFSET n_WrtOffset,n_RegOffset;
 {
        EMUFS_REG_ID n_IdReg;
        EMUFS_FREE n_FreeSpace;
        EMUFS_OFFSET n_WrtOffset,n_RegOffset;

+       unsigned long int n_FisicSize;

        FILE *f_data;
        char name_f[255];
        
        /* Armamos el filename del archivo de datos */
        FILE *f_data;
        char name_f[255];
        
        /* Armamos el filename del archivo de datos */

-       strcpy(name_f,emu->nombre);
+       strcpy(name_f,efs->nombre);

        strcat(name_f,".dat");
        
        strcat(name_f,".dat");
        

-       if ( (f_data = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+       if ( (f_data = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/

        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */
        
        /* Obtengo un offset en donde iniciar la escritura de mi registro */
        /* de manera segura (habra espacio suficiente) */

-       n_WrtOffset = emufs_fsc_buscar_lugar(emu, n_RegSize, &n_FreeSpace);
+       n_FisicSize = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+n_RegSize;
+       n_WrtOffset = emufs_fsc_buscar_lugar(efs,n_FisicSize,&n_FreeSpace);

        printf("tipo2.c >> Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
        
        /* Si no encontre un gap, entonces escribo el registro al final */
        if (n_WrtOffset == -1) {                       
                
                /* Obtengo un ID libre para el registro y luego grabo a disco */
        printf("tipo2.c >> Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);
        
        /* Si no encontre un gap, entonces escribo el registro al final */
        if (n_WrtOffset == -1) {                       
                
                /* Obtengo un ID libre para el registro y luego grabo a disco */

-        n_IdReg = emufs_tipo2_get_id(emu);
+        n_IdReg = emufs_idx_get_new_id(efs, err);

                fseek(f_data, 0, SEEK_END);
                n_RegOffset = ftell(f_data);
 
                /* Escribo [RegId]|[RegSize]|[RegData] */
                fseek(f_data, 0, SEEK_END);
                n_RegOffset = ftell(f_data);
 
                /* Escribo [RegId]|[RegSize]|[RegData] */

-               fwrite(&n_IdReg,sizeof(int),1,f_data);
-               fwrite(&n_RegSize,sizeof(int),1,f_data);
+               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);

                fwrite(ptr,n_RegSize,1,f_data);
                                
                /* Bye */
                fwrite(ptr,n_RegSize,1,f_data);
                                
                /* Bye */

-               printf("Tipo2.c >> RegNr: %lu inserted at Offset: %lu\n",n_IdReg,n_RegOffset);
+               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);

                fclose(f_data);
                
        } else {
                
                fclose(f_data);
                
        } else {
                

+               /* Obtengo un ID libre para el registro y luego grabo en disco */
+        n_IdReg = emufs_idx_get_new_id(efs, err);
+               n_RegOffset = n_WrtOffset;
+               fseek(f_data,n_RegOffset,0);
+               
+        /* Escribo [RegId]|[RegSize]|[RegData] */
+               fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data);
+               fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);
+               fwrite(ptr,n_RegSize,1,f_data);
+                               
+               /* Bye */
+               printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);
+               fclose(f_data);
+               
+               /* Actualizo el espacio libre en el GAP donde puse el registro */
+               if ((n_FreeSpace-n_FisicSize) == 0) emufs_fsc_remove_gap(efs,n_RegOffset);
+               else emufs_fsc_actualizar_gap(efs,n_RegOffset,n_FreeSpace-n_FisicSize);         

        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */
        }
                
        /* Finalmente, actualizamos el indice de registros (offsets) */

-       emufs_idx_agregar(emu,n_IdReg,n_RegOffset);
+       emufs_idx_agregar(efs,n_IdReg,n_RegOffset);

                
        return n_IdReg;
 }
 
 /**********************************************************************/
                
        return n_IdReg;
 }
 
 /**********************************************************************/

-/* int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)  */
+/* int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)  */

 /* Objetivo: Borra un registro determinado y actualiza los archivos   */
 /*           de Posicion Relativa (Indice-Offset) y el de Gaps        */
 /* Objetivo: Borra un registro determinado y actualiza los archivos   */
 /*           de Posicion Relativa (Indice-Offset) y el de Gaps        */

-/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */

 /*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
 /**********************************************************************/
 /*             EMUFS_REG_ID n_IdReg // Id del registro a eliminar.    */
 /**********************************************************************/

-int emufs_tipo2_borrar_registro(EMUFS *emu, EMUFS_REG_ID n_IdReg)
+int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg)

 {      
 {      

-       FILE *f_data;
-       char name_f[255];
-       EMUFS_OFFSET n_RegOffset;
+       EMUFS_OFFSET n_RegOffset,n_RegSize;

         
         

-    /* Armamos el filename del archivo de datos */
-       strcpy(name_f,emu->nombre);
-       strcat(name_f,".dat");
-
-       /* Obtenemos el tamanio del bloque */
-       if ((n_RegOffset = emufs_idx_buscar_registro(emu,n_IdReg)) != -1)
+       /* Obtenemos el offset donde arranca el registro */
+       if ((n_RegOffset = emufs_idx_buscar_registro(efs,n_IdReg)) != -1)

          printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
        else 
          return -1;
          printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset);
        else 
          return -1;

-                       
-       if ((f_data = fopen(name_f,"a+")) == NULL) return -1; /* ERROR */
-       fclose(f_data);
+       
+       /* Obtenemos el Size del Registro en cuestion y hacemos un dummfill*/
+       emufs_tipo2_get_regsize(efs,n_RegOffset,&n_RegSize);
+       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 hallarlo. */
+       emufs_fsc_agregar_gap(efs,n_RegOffset,n_RegSize+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));
+       
+       /* Agrego el ID que se ha liberado al archivo de ID's Libres */
+       emufs_did_agregar(efs,n_IdReg); 
+       
+       /* Borramos el registro del indice de posiciones relativas */
+       /*emufs_idx_borrar(efs,n_IdReg);*/

        
        return(0);
 }
 
 /**********************************************************************/
        
        return(0);
 }
 
 /**********************************************************************/

-/* EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)                        */
-/* Objetivo: Devuelve un Id apropiado y disponible para un nuevo reg  */
-/* Parametros: EMUFS *emu // Struct con handlers + info del openfile. */
+/* int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos,     */
+/*                             EMUFS_REG_SIZE *n_RegSize)             */
+/* Objetivo: Devuelve el tamanio de un registro, dado su init offset  */
+/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
+/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
+/*             EMUFS_REG_SIZE *n_RegSize // Size to lookup and return */
+/**********************************************************************/
+int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n_RegSize)
+{
+    FILE *f_data;
+       char name_f[255];
+
+    /* 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 */
+       fseek(f_data,n_RegPos+sizeof(EMUFS_REG_ID),SEEK_SET);
+       fread(n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data);               
+       fclose(f_data);
+       
+       return (0);
+}
+
+/**********************************************************************/
+/* int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos,       */
+/*                           EMUFS_REG_SIZE n_Amount                  */
+/* Objetivo: Pisa con basura lo que es hasta el momento un reg en     */
+/*           el disco para indicar su borrado (Debug Purposes Only).  */
+/* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */
+/*             EMUFS_OFFSET n_RegPos // Offset al inicio del registro */
+/*             EMUFS_REG_SIZE *n_Amount // Size to lookup and return  */

 /**********************************************************************/
 /**********************************************************************/

-EMUFS_REG_ID emufs_tipo2_get_id(EMUFS *emu)
+int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Amount)

 {
 {

-       EMUFS_REG_ID n_RegId;
+    FILE *f_data;
+       char name_f[255];
+    void *dummyfill;
+       void *ptr_cur;
+       unsigned long n_FillSize,n_count;
+       
+    /* Armamos el filename del archivo de datos */
+       strcpy(name_f,efs->nombre);
+       strcat(name_f,".dat");

 
 

-       /* Si no se hallo un id libre, entonces debo usar el maximo + 1 */
-       if ( (n_RegId = emufs_did_get_last(emu)) == -1 )
-               n_RegId = emufs_idx_buscar_mayor_id(emu);
+    if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */

        
        

-       return n_RegId; 
+       /* Preparo el garbage y se lo tiro encima */
+       n_FillSize = n_Amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
+       dummyfill = (char*)malloc(n_FillSize);
+       ptr_cur = dummyfill;
+       for (n_count = 0; n_count < n_FillSize; ++n_count) memcpy(ptr_cur+n_count,"#",1);
+       fseek(f_data,n_RegPos,SEEK_SET);
+       fwrite(dummyfill,n_FillSize,1,f_data);
+       fclose(f_data);
+       
+       /* printf("Dummy Fill: %s\n",dummyfill); */ /*Uncomment to check */
+       
+       return (0);

 }
 }

+