Se pone bien la memoria en cero para la GUI en borrar_registro.

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 0e981af7458c361f547e647fc1fc0b71783619f4..a442e8d7c272a24c9a65df3fc2850620fc1e78fa 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -177,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) {


@@ -193,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;


@@ -205,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)


@@ -266,10 +240,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;


@@ -338,6 +314,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);


@@ -401,12 +381,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");


@@ -450,8 +432,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) */


@@ -475,9 +463,12 @@ 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)
 {
 EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
 {

-       int err = 0,err1 = 0, err2 = 0, err3 = 0;
+       int err = 0;

        EMUFS_Estadisticas stats;
        memset(&stats, 0, sizeof(EMUFS_Estadisticas));
 
        EMUFS_Estadisticas stats;
        memset(&stats, 0, sizeof(EMUFS_Estadisticas));
 


@@ -513,10 +504,11 @@ EMUFS_Estadisticas emufs_tipo1_leer_estadisticas(EMUFS* efs)
        emufs_fsc_get_max_min_fs(efs, &stats.min_fs, &stats.max_fs);
        
        /* obtengo informacion de control guardada por los archivos auxiliares */
        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,&err1) + emufs_fsc_get_file_size(efs,&err2)
-                                                       + emufs_did_get_file_size(efs,&err3);
-       if (err1 || err2 || err3) {
-               PERR("Hubo problemas en lectura de filesize 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;
        }