Se reimplementa leer_registro_raw() y se rellena espacio libre con ceros para GUI.

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 27b0dc999469f85cc497a19dc8f9afe733bb7f83..73ea3e24a85d3bf42593434210cb3a66316b6eb5 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -39,9 +39,9 @@
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"
 #include "idx.h"
 #include "fsc.h"
 #include "did.h"

+#include "common.h"

 #include "error.h"
 #include <unistd.h>
 #include "error.h"
 #include <unistd.h>

-#include <sys/types.h>

 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>


@@ -75,9 +75,6 @@ static void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 

-/** Obtiene el tamaño del archivo. */
-static long emufs_tipo1_get_file_size(EMUFS*, int*);
-

 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)
 /*------------------ Funciones públicas ----------------------*/
 
 int emufs_tipo1_inicializar(EMUFS* efs)


@@ -98,6 +95,7 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;
        efs->leer_registro_raw = emufs_tipo1_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo1_leer_estadisticas;
        efs->compactar         = emufs_tipo1_compactar;

+       efs->tam_reg = 0;

        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 


@@ -179,14 +177,11 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 
 void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
 {
 
 void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *size, int *pos)
 {

-       char *chunk_ptr;

        char* block; /* bloque leido (en donde está el registro a leer) */
        char* block; /* bloque leido (en donde está el registro a leer) */

-       char* registro; /* registro a leer */
-       EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
-       EMUFS_BLOCK_SIZE offset, block_space; /* offset del bloque leído */
+       EMUFS_BLOCK_ID block_id; /* bloque en donde esta el registro a leer */
+       EMUFS_BLOCK_SIZE offset; /* offset del bloque leído */

        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */

-       EMUFS_REG_SIZE cant_bloques;
-       int err = 0, i;
+       int err = 0;

 
        block_id = emufs_idx_buscar_registro(efs, id);
        if (block_id == EMUFS_NOT_FOUND) {
 
        block_id = emufs_idx_buscar_registro(efs, id);
        if (block_id == EMUFS_NOT_FOUND) {


@@ -195,7 +190,6 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
                *size = 0;
                return NULL;
        }
                *size = 0;
                return NULL;
        }

-       err = 0;

        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                PERR("no se pudo reservar memoria");
                *pos = 0;
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                PERR("no se pudo reservar memoria");
                *pos = 0;


@@ -207,45 +201,23 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE
        offset = 0;
        do {
                /* copio la cabecera del registro actual. */
        offset = 0;
        do {
                /* copio la cabecera del registro actual. */

-               memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
+               memcpy(&curr_reg_header, block + offset,
+                               sizeof(EMUFS_TIPO1_REG_HEADER));

                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == id) {
                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == id) {

-                       /* tamaño máximo ultilizable para datos en un bloque */
-                       *pos = offset-sizeof(EMUFS_TIPO1_REG_HEADER);
-                       block_space = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
-                       /* tamaño de la porción de registro que se guarda */
-
-                       cant_bloques = curr_reg_header.size / block_space + 1;
-                       *size = cant_bloques*efs->tam_bloque;
-                       registro = chunk_ptr = (char*) malloc(*size - (cant_bloques-1)*sizeof(EMUFS_TIPO1_REG_HEADER) + (cant_bloques-1)*2);
-                       if (registro == NULL) {
-                               free(block);
-                               PERR("No hay memoria");
-                               *pos = 0;
-                               *size = 0;
-                               return NULL;
-                       }
-                       memcpy(registro, block, efs->tam_bloque);
-                       chunk_ptr += efs->tam_bloque;
-                       /* copio los otros bloques, si los hay */
-                       free(block);
-                       for (i = 1; i < cant_bloques; ++i) {
-                               err = 0;
-                               block = (char*)emufs_tipo1_leer_bloque(efs, block_id+i, &err);
-                               /* Solo grabo el header del primer pedazo! */
-                               memcpy(chunk_ptr, "<>", 2);
-                               chunk_ptr += 2;
-                               memcpy(chunk_ptr, block+sizeof(EMUFS_TIPO1_REG_HEADER), efs->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER));
-                               chunk_ptr += efs->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER);
-                               free(block);
-                       }
-                       break; /* se terminó el trabajo. */
+                       /* posición del comienzo del registro, incluye cabecera */
+                       *pos = offset - sizeof(EMUFS_TIPO1_REG_HEADER);
+                       *size = efs->tam_bloque; /* tamaño del bloque leido */
+                       return block; /* devuelvo el puntero al bloque */

                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;
        } while (offset < efs->tam_bloque);
 
                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;
        } while (offset < efs->tam_bloque);
 

-       return registro;
+       /* no se encontró el registro, no debería pasar nunca */
+       PERR("No se encontró el registro en el bloque indicado por el .idx");
+       free(block);
+       return NULL;

 }
 
 void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int* err)
 }
 
 void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int* err)


@@ -340,6 +312,8 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                /* graba porción del registro en bloque */ /* destino: fin de bloque */
                emufs_tipo1_escribir_reg_chunk_en_memoria(block + efs->tam_bloque - fs,
                                header, chunk_ptr, chunk_size);
                /* graba porción del registro en bloque */ /* destino: fin de bloque */
                emufs_tipo1_escribir_reg_chunk_en_memoria(block + efs->tam_bloque - fs,
                                header, chunk_ptr, chunk_size);

+               /* rellena el espacio libre con ceros para la GUI */
+               if (fs) memset(block + efs->tam_bloque - fs, 0, fs);

                /* graba el bloque en el archivo */
                new_block_id = emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                fs - sizeof(EMUFS_TIPO1_REG_HEADER) - chunk_size, err);
                /* graba el bloque en el archivo */
                new_block_id = emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id,
                                fs - sizeof(EMUFS_TIPO1_REG_HEADER) - chunk_size, err);


@@ -454,6 +428,9 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                                        /* muevo la porción de bloque a izquierda */
                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);
                                        /* muevo la porción de bloque a izquierda */
                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);

+                                       /* rellena el espacio libre con ceros para la GUI */
+                                       if (fs) memset(block + offset_reg_end, 0,
+                                                       efs->tam_bloque - offset_reg_end);

                                }
                        }
                        /* guardo el bloque en disco (actualizando espacio libre) */
                                }
                        }
                        /* guardo el bloque en disco (actualizando espacio libre) */


@@ -477,37 +454,54 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 

+/* \bug Si hay registros multibloque, no se calcula bien el
+ *         stats.tam_info_control_dat.
+ */

 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 {
        int err = 0;
        EMUFS_Estadisticas stats;
        memset(&stats, 0, sizeof(EMUFS_Estadisticas));
 
 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 {
        int err = 0;
        EMUFS_Estadisticas stats;
        memset(&stats, 0, sizeof(EMUFS_Estadisticas));
 

-       stats.tam_archivo_bytes = emufs_tipo1_get_file_size(efs, &err);
-       if (err) {
-               PERR("no se pudo obtener el tamaño del archivo");
-               return stats;
+       { /* obtengo tamaño del archivo en bytes */
+               char name_f[255];
+               strcpy(name_f, efs->nombre);
+               strcat(name_f, ".dat");
+               stats.tam_archivo = emufs_common_get_file_size(name_f, &err);
+               if (err) {
+                       PERR("no se pudo obtener el tamaño del archivo");
+                       return stats;
+               }

        }
 
        }
 

-       /* obtengo cantidad de bloques */
-       stats.cant_bloques = (stats.tam_archivo_bytes - emufs_tipo1_header_size())
+       /* obtengo cantidad de bloques en el archivo */
+       stats.cant_bloques = (stats.tam_archivo - emufs_tipo1_header_size())

                        / efs->tam_bloque;
 
        /* obtengo la cantidad de registros en el archivo */
        {
                        / efs->tam_bloque;
 
        /* obtengo la cantidad de registros en el archivo */
        {

-               EMUFS_REG_ID *tmp = emufs_idx_get(efs, &stats.tam_archivo);
+               EMUFS_REG_ID *tmp = emufs_idx_get(efs, &stats.cant_registros);

                if (tmp) free(tmp); /* libera memoria innecesaria */
        }
 
                if (tmp) free(tmp); /* libera memoria innecesaria */
        }
 

-       /* obtengo total de información de control que guarda el archivo */
-       stats.info_control = emufs_tipo1_header_size() /* cabecera del archivo */
+       /* obtengo información de control que guarda el archivo .dat */
+       stats.tam_info_control_dat = emufs_tipo1_header_size() /* cabecera del archivo */

                        /* mas las cabeceras de todos los registros */
                        /* mas las cabeceras de todos los registros */

-                       + stats.tam_archivo * sizeof(EMUFS_TIPO1_REG_HEADER);
+                       + stats.cant_registros * sizeof(EMUFS_TIPO1_REG_HEADER);

 
        /* obtengo las estadísticas del archivo de espacio libre por bloque */
        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);
 
        /* obtengo las estadísticas del archivo de espacio libre por bloque */
        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);

+       
+       /* obtengo informacion de control guardada por los archivos auxiliares */
+       stats.tam_archivos_aux = emufs_idx_get_file_size(efs, &err)
+               + emufs_fsc_get_file_size(efs, &err)
+               + emufs_did_get_file_size(efs, &err);
+       if (err) {
+               PERR("error al obtener tamaño de alguno de los archivos auxiliares");
+               return stats;
+       }       

 
        return stats;   
 }
 
        return stats;   
 }


@@ -584,10 +578,20 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 {
        FILE* file;
        char name_f[255];
 {
        FILE* file;
        char name_f[255];

+       EMUFS_BLOCK_SIZE num_blocks;
+
+       /* obtengo nombre del archivo */
+       strcpy(name_f, efs->nombre);
+       strcat(name_f,".dat");
+

        /* obtengo cantidad de bloques */
        /* obtengo cantidad de bloques */

-       EMUFS_BLOCK_SIZE num_blocks =
-               (emufs_tipo1_get_file_size(efs, err) - emufs_tipo1_header_size())
+       num_blocks =
+               (emufs_common_get_file_size(name_f, err) - emufs_tipo1_header_size())

                / efs->tam_bloque;
                / efs->tam_bloque;

+       if (*err) {
+               PERR("Error al obtener tamaño del archivo.");
+               return EMUFS_NOT_FOUND;
+       }

 
        /* abre archivo */
        strcpy(name_f,efs->nombre);
 
        /* abre archivo */
        strcpy(name_f,efs->nombre);


@@ -694,24 +698,6 @@ void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,
        memcpy(dst, reg, reg_size);
 }
 
        memcpy(dst, reg, reg_size);
 }
 

-long emufs_tipo1_get_file_size(EMUFS* efs, int* err)
-{
-       long  file_size;
-       FILE* file;
-       char  name_f[255];
-
-       strcpy(name_f, efs->nombre);
-       strcat(name_f, ".dat");
-       if ((file = fopen(name_f, "ab")) == NULL) {
-               PERR("Error al abrir archivo");
-               *err = EMUFS_ERROR_CANT_OPEN_FILE;
-               return 0;
-       }
-       file_size = ftell(file);
-       fclose(file);
-       return file_size;
-}
-

 void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 {
        int err = 0;
 void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente, EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
 {
        int err = 0;


@@ -720,4 +706,3 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }
        (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err);
        (*size1) = (*size2) = (*size3) = efs->tam_bloque;
 }

-