leer_registro() ya soporta registros que ocupen mas de un bloque.

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 8bccc4ce03bf2a1d8b40f14150e9aa9d8f77938e..5dbf6f3695987fc902895fc0c1444bd12bfaa76c 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -100,7 +100,8 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
                /* TODO Manejo de errores */
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) {
                /* TODO Manejo de errores */

-               PERR("no se pudo leer el bloque");
+               PERR("no se pudo reservar memoria");
+               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */

                return NULL;
        }
 
                return NULL;
        }
 


@@ -111,7 +112,11 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == reg_id) {
                memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER));
                offset += sizeof(EMUFS_TIPO1_REG_HEADER);
                if (curr_reg_header.id == reg_id) {

-                       registro = (char*) malloc(curr_reg_header.size);
+                       /* tamaño máximo ultilizable para datos en un bloque */
+                       EMUFS_BLOCK_SIZE block_space
+                                       = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+                       *reg_size = curr_reg_header.size;
+                       registro = (char*) malloc(*reg_size);

                        if (registro == NULL) {
                                /* TODO Manejo de errores */
                                free(block);
                        if (registro == NULL) {
                                /* TODO Manejo de errores */
                                free(block);


@@ -119,8 +124,38 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
                                *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
                                return NULL;
                        }
                                *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
                                return NULL;
                        }

-                       memcpy(registro, block + offset, curr_reg_header.size);
-                       *reg_size = curr_reg_header.size;
+                       /* Si el registro ocupa más de un bloque */
+                       if (*reg_size > block_space) {
+                               /* TODO */
+                               /* tamaño de la porción de registro que se guarda */
+                               EMUFS_REG_SIZE chunk_size = 0; 
+                               /* puntero a la porción actual del registro */
+                               char* chunk_ptr = registro;
+
+                               while (1) {
+                                       chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+                                       curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
+                                       chunk_size = MIN(curr_reg_header.size, block_space);
+                                       /* copio porción de registro en el buffer */
+                                       memcpy(chunk_ptr, block + offset, chunk_size);
+                                        /* falta leer un bloque */
+                                       if (curr_reg_header.size > block_space) {
+                                               free(block);
+                                               if (!(block = (char*) emufs_tipo1_leer_bloque(efs,
+                                                                               ++block_id, err))) {
+                                                       /* TODO Manejo de errores */
+                                                       free(registro);
+                                                       PERR("no se pudo reservar memoria");
+                                                       *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                                                       return NULL;
+                                               }
+                                       } else { /* se terminó de leer */
+                                               break;
+                                       }
+                               }
+                       } else {
+                               memcpy(registro, block + offset, *reg_size);
+                       }

                        break;
                }
                /* Desplazo el offset */
                        break;
                }
                /* Desplazo el offset */


@@ -131,6 +166,36 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
        return registro;
 }
 
        return registro;
 }
 

+#if 0
+                       /* 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 de la porción de registro que se guarda */
+                       EMUFS_REG_SIZE chunk_size = 0; 
+                       /* puntero a la porción actual del registro */
+                       char* chunk_ptr;
+                       /* puntero a la posición actual del bloque */
+                       char* block_ptr = block + offset;
+
+                       *reg_size = curr_reg_header.size; /* obtengo tamaño del registro */
+                       registro = chunk_ptr = (char*) malloc(*reg_size);
+                       if (registro == NULL) {
+                               /* TODO Manejo de errores */
+                               free(block);
+                               PERR("No hay memoria");
+                               *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
+                               return NULL;
+                       }
+                       do {
+                               block_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+                               chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+                               curr_reg_header.size -= chunk_size; /* Resto lo que ya guardé */
+                               chunk_size = MIN(curr_reg_header.size, block_space);
+                               /* copio porción de registro en el buffer */
+                               memcpy(chunk_ptr, block_ptr, chunk_size);
+                       } while (curr_reg_header.size > block_space);
+#endif
+

 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)
 {


@@ -223,7 +288,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        if (block_id == EMUFS_NOT_FOUND) {
                /* tamaño máximo ultilizable para datos en un bloque */
                EMUFS_BLOCK_SIZE block_space
        if (block_id == EMUFS_NOT_FOUND) {
                /* tamaño máximo ultilizable para datos en un bloque */
                EMUFS_BLOCK_SIZE block_space

-                       = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);
+                               = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER);

                /* identificador del bloque que se guarda */
                EMUFS_BLOCK_ID curr_block_id = EMUFS_NOT_FOUND;
                /* tamaño de la porción de registro que se guarda */
                /* identificador del bloque que se guarda */
                EMUFS_BLOCK_ID curr_block_id = EMUFS_NOT_FOUND;
                /* tamaño de la porción de registro que se guarda */


@@ -257,9 +322,10 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                                return EMUFS_NOT_FOUND;
                        }
                        /* grabo el nuevo registro en el archivo de espacios libres */
                                return EMUFS_NOT_FOUND;
                        }
                        /* grabo el nuevo registro en el archivo de espacios libres */

-                       *err = emufs_fsc_agregar(efs, block_id, block_space - chunk_size);
+                       *err = emufs_fsc_agregar(efs, curr_block_id, block_space - chunk_size);

                        if (*err) {
                                PERR("No se pudo agregar fsc");
                        if (*err) {
                                PERR("No se pudo agregar fsc");

+                               free(block);

                                return EMUFS_NOT_FOUND;
                        }
                        /* si es el primer id de bloque obtenido, lo guardo para
                                return EMUFS_NOT_FOUND;
                        }
                        /* si es el primer id de bloque obtenido, lo guardo para


@@ -267,7 +333,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                        if (block_id == EMUFS_NOT_FOUND) {
                                block_id = curr_block_id;
                        }
                        if (block_id == EMUFS_NOT_FOUND) {
                                block_id = curr_block_id;
                        }

-               } while (chunk_size > block_space);
+               } while (reg_header.size > block_space);

                free(block);
 
        /* Encontró espacio en un bloque existente, graba registro ahí */
                free(block);
 
        /* Encontró espacio en un bloque existente, graba registro ahí */