* Empieza el baile de usar indices desde la gui

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index fbebc53fdcedcdca12bb19aa44a3526dae78d3da..55c98411607ca03da6dc80f5e5bbb6d8b433150b 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)


@@ -102,13 +99,14 @@ int emufs_tipo1_inicializar(EMUFS* efs)
        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 

-void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
+void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave,

                EMUFS_REG_SIZE* reg_size, int *err)
 {
        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; /* offset del bloque leído */
                EMUFS_REG_SIZE* reg_size, int *err)
 {
        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; /* offset del bloque leído */

+       EMUFS_REG_ID reg_id;

        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);
        EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 
        block_id = emufs_idx_buscar_registro(efs, reg_id);


@@ -180,14 +178,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) {


@@ -196,7 +191,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;


@@ -208,45 +202,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)


@@ -269,10 +241,12 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int* err)
        if (block == NULL) {
                PERR("No hay memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;
        if (block == NULL) {
                PERR("No hay memoria");
                *err = EMUFS_ERROR_OUT_OF_MEMORY;

+               fclose(file);

                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {
                free(block);
                return NULL;
        }
        if (fread(block, efs->tam_bloque, 1, file) != 1) {
                free(block);

+               fclose(file);

                PERR("Error al leer bloque");
                *err = EMUFS_ERROR_FILE_READ;
                return NULL;
                PERR("Error al leer bloque");
                *err = EMUFS_ERROR_FILE_READ;
                return NULL;


@@ -341,6 +315,10 @@ 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 */
+               memset(block + efs->tam_bloque - fs + chunk_size
+                               + sizeof(EMUFS_TIPO1_REG_HEADER), 0,
+                               fs - chunk_size - sizeof(EMUFS_TIPO1_REG_HEADER));

                /* 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);


@@ -404,12 +382,14 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                        /* tamaño máximo ultilizable para datos en un bloque */
                        EMUFS_BLOCK_SIZE block_space
                                        = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
                        /* tamaño máximo ultilizable para datos en un bloque */
                        EMUFS_BLOCK_SIZE block_space
                                        = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);

-                       EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */
+                       /* cantidad de espacio libre original del ultimo bloque */
+                       EMUFS_FREE orig_fs; 

 
                        while (1) {
 
                        while (1) {

+                               EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */
+                               orig_fs = emufs_fsc_get_fs(efs, curr_block_id);

                                /* actualizo archivo de espacio libre por bloque */
                                /* actualizo archivo de espacio libre por bloque */

-                               fs = emufs_fsc_get_fs(efs, curr_block_id)
-                                       + MIN(curr_reg_header.size, block_space)
+                               fs = orig_fs + MIN(curr_reg_header.size, block_space)

                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
                                        PERR("no se pudo actualizar .fsc");
                                        + sizeof(EMUFS_TIPO1_REG_HEADER);
                                if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) {
                                        PERR("no se pudo actualizar .fsc");


@@ -453,8 +433,14 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id)
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */

+                                       /* XXX Este memcpy() puede copiar regiones de memoria que
+                                        * se superponen, si copia de principio a fin y byte a byte
+                                        * no debería haber problema */

                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);
                                        memcpy(block + offset, block + offset_reg_end,
                                                efs->tam_bloque - offset_reg_end);

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

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


@@ -478,43 +464,61 @@ 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;   
 }
 
 void emufs_tipo1_compactar(EMUFS* efs)
 {
 
        return stats;   
 }
 
 void emufs_tipo1_compactar(EMUFS* efs)
 {

+#ifdef ARREGLAR

        EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */
                = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
        EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */
        EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */
                = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
        EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */


@@ -578,6 +582,7 @@ void emufs_tipo1_compactar(EMUFS* efs)
                        emufs_fsc_truncate(efs, block_id);
                }
        }
                        emufs_fsc_truncate(efs, block_id);
                }
        }

+#endif

 }
 
 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 }
 
 EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,


@@ -585,10 +590,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);


@@ -695,24 +710,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;


@@ -721,4 +718,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;
 }

-