Soporte para bloques mas chicos que el registro.

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 1c48211d96f671da8346d026a1ece846abfe2dac..f1cc3c92ee820515555bd024c3abe87ea79b6d97 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -1,4 +1,4 @@
-/* vim: set noexpandtab tabstop=4 shiftwidth=4:
+/* vim: set noexpandtab tabstop=4 shiftwidth=4 wrap:

  *----------------------------------------------------------------------------
  *                                  emufs
  *----------------------------------------------------------------------------
  *----------------------------------------------------------------------------
  *                                  emufs
  *----------------------------------------------------------------------------


@@ -114,8 +114,13 @@ void* emufs_tipo1_leer_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);

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

                        *reg_size = curr_reg_header.size;
                        *reg_size = curr_reg_header.size;

-                       registro = (char*) malloc(*reg_size);
+                       registro = chunk_ptr = (char*) malloc(*reg_size);

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


@@ -123,37 +128,26 @@ 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;
                        }

-                       /* 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;
+                       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;
                }
                        }
                        break;
                }


@@ -165,43 +159,11 @@ 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)

 {
        char* block; /* bloque leido (en donde está el 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 */
 {
        char* block; /* bloque leido (en donde está el 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_BLOCK_SIZE block_size; /* tamaño del bloque leído */

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


@@ -209,6 +171,7 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
        if (block_id == EMUFS_NOT_FOUND) {
                return NULL;
        }
        if (block_id == EMUFS_NOT_FOUND) {
                return NULL;
        }

+       err = 0;

        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                return NULL;
        }
        if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) {
                return NULL;
        }


@@ -225,9 +188,9 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id,
                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;
                }
                /* Desplazo el offset */
                offset += curr_reg_header.size;

-       } while (offset < block_size);
+       } while (offset < efs->tam_bloque);

 
 

-       (*size) = block_size;
+       (*size) = efs->tam_bloque;

        return block;
 }
 
        return block;
 }
 


@@ -266,8 +229,7 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err)
        return block;
 }
 
        return block;
 }
 

-EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
-               EMUFS_REG_SIZE reg_size, int* err)
+EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, EMUFS_REG_SIZE reg_size, int* err)

 {
        EMUFS_TIPO1_REG_HEADER reg_header; /* cabecera del registro a guardar */
        EMUFS_FREE             fs; /* espacio libre en el bloque */
 {
        EMUFS_TIPO1_REG_HEADER reg_header; /* cabecera del registro a guardar */
        EMUFS_FREE             fs; /* espacio libre en el bloque */


@@ -286,8 +248,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        /* si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (block_id == EMUFS_NOT_FOUND) {
                /* tamaño máximo ultilizable para datos en un bloque */
        /* si no hay bloques con suficiente espacio creo un bloque nuevo */
        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);
+               EMUFS_BLOCK_SIZE block_space = 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 */


@@ -310,11 +271,9 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
                        reg_header.size -= chunk_size; /* Resto lo que ya guardé */
                        chunk_size = MIN(reg_header.size, block_space);
                        /* graba porción del registro en bloque */
                        reg_header.size -= chunk_size; /* Resto lo que ya guardé */
                        chunk_size = MIN(reg_header.size, block_space);
                        /* graba porción del registro en bloque */

-                       emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header,
-                                       chunk_ptr, chunk_size);
+                       emufs_tipo1_escribir_reg_chunk_en_memoria(block, reg_header, chunk_ptr, chunk_size);

                        /* graba el bloque en el archivo */
                        /* graba el bloque en el archivo */

-                       curr_block_id = emufs_tipo1_grabar_bloque(efs, block,
-                                       EMUFS_NOT_FOUND, err);
+                       curr_block_id = emufs_tipo1_grabar_bloque(efs, block, EMUFS_NOT_FOUND, err);

                        if (*err) {
                                PERR("error al grabar bloque");
                                free(block);
                        if (*err) {
                                PERR("error al grabar bloque");
                                free(block);