X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/2c7745e0cdf6a82f3f24f02f0decdf0efbe13f90..840e216ee1d0b23864f75f44ba549899669d9595:/emufs/tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index dc6a813..a547479 100644
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -88,7 +88,6 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 	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_BLOCK_SIZE block_size; /* tamaño del bloque leído */
 	EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */
 
 	block_id = emufs_idx_buscar_registro(efs, reg_id);
@@ -100,7 +99,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 */
-		PERR("no se pudo leer el bloque");
+		PERR("no se pudo reservar memoria");
+		*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 		return NULL;
 	}
 
@@ -111,7 +111,16 @@ 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) {
-			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);
+			/* 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;
+			registro = chunk_ptr = (char*) malloc(*reg_size);
 			if (registro == NULL) {
 				/* TODO Manejo de errores */
 				free(block);
@@ -119,13 +128,32 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id,
 				*err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 				return NULL;
 			}
-			memcpy(registro, block + offset, curr_reg_header.size);
-			*reg_size = curr_reg_header.size;
+			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;
+				}
+			}
 			break;
 		}
 		/* Desplazo el offset */
 		offset += curr_reg_header.size;
-	} while (offset < block_size);
+	} while (offset < efs->tam_bloque);
 
 	free(block);
 	return registro;
@@ -205,25 +233,32 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, 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;
-	EMUFS_FREE             fs;
-	EMUFS_BLOCK_ID         block_id;
+	EMUFS_TIPO1_REG_HEADER reg_header; /* cabecera del registro a guardar */
+	EMUFS_FREE             fs; /* espacio libre en el bloque */
+	EMUFS_BLOCK_ID         block_id; /* identificador del 1er bloque */
+	char*                  block; /* buffer del bloque a guardar en disco */
 	char                   name_f[255];
-	char*                  block;
 
 	strcpy(name_f, efs->nombre);
 	strcat(name_f, ".dat");
 
 	/* pongo tamaño del registro en la cabecera. */
 	reg_header.size = reg_size;
-	/* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
-	block_id = emufs_fsc_buscar_lugar(efs, reg_size
-			+ sizeof(EMUFS_TIPO1_REG_HEADER), &fs);
+	/* busco lugar para el registro en un bloque existente */
+	block_id = emufs_fsc_buscar_lugar(efs, sizeof(EMUFS_TIPO1_REG_HEADER)
+			+ reg_size, &fs);
 	/* 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;
-		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);
+		/* 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 */
+		EMUFS_REG_SIZE chunk_size = 0; 
+		/* puntero a la poción del registro */
+		char* chunk_ptr = reg; 
+
 		/* crear un nuevo bloque en memoria */
 		block = (char*) malloc(efs->tam_bloque);
 		if (block == NULL) {
@@ -233,51 +268,36 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
 			return EMUFS_NOT_FOUND;
 		}
 		reg_header.id = emufs_idx_get_new_id(efs, err);
-		memset(block, 0, efs->tam_bloque); /* inicializa bloque */
-		/* verifica que el registro no sea más grande que el bloque */
-		if (reg_size > block_space) {
-			EMUFS_REG_SIZE chunk_size = 0; /* Tamaño de la porción de registro */
-			char* chunk_pointer = reg; /* Puntero a la poción del registro */
-			do {
-				memset(block, 0, efs->tam_bloque); /* inicializa bloque */
-				reg_header.size -= chunk_size;
-				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, reg,
-						chunk_size);
-				/* graba el bloque en el archivo */
-				block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
-				if (*err) {
-					PERR("error al grabar bloque");
-					free(block);
-					return EMUFS_NOT_FOUND;
-				}
+		do {
+			memset(block, 0, efs->tam_bloque); /* inicializa bloque */
+			chunk_ptr += chunk_size; /* Avanzo para guardar prox chunk */
+			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);
+			/* graba el bloque en el archivo */
+			curr_block_id = emufs_tipo1_grabar_bloque(efs, block,
+					EMUFS_NOT_FOUND, err);
+			if (*err) {
+				PERR("error al grabar bloque");
 				free(block);
-				/* grabo el nuevo registro en el archivo de espacios libres */
-				*err = emufs_fsc_agregar(efs, block_id, block_space - chunk_size);
-				if (*err) {
-					PERR("No se pudo agregar fsc");
-					return EMUFS_NOT_FOUND;
-				}
-			} while (chunk_size > block_space);
-		}
-		/* graba registro en bloque */
-		emufs_tipo1_escribir_reg_en_memoria(block, reg_header, reg);
-		/* graba el bloque en el archivo */
-		block_id = emufs_tipo1_grabar_bloque(efs, block, block_id, err);
-		if (*err) {
-			PERR("error al grabar bloque");
-			free(block);
-			return EMUFS_NOT_FOUND;
-		}
+				return EMUFS_NOT_FOUND;
+			}
+			/* grabo el nuevo registro en el archivo de espacios libres */
+			*err = emufs_fsc_agregar(efs, curr_block_id, block_space - chunk_size);
+			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
+			 * agregarlo después al archivo de índices. */
+			if (block_id == EMUFS_NOT_FOUND) {
+				block_id = curr_block_id;
+			}
+		} while (reg_header.size > block_space);
 		free(block);
-		/* grabo el nuevo registro en el archivo de espacios libres */
-		*err = emufs_fsc_agregar(efs, block_id, efs->tam_bloque - reg_size
-				- sizeof(EMUFS_TIPO1_REG_HEADER));
-		if (*err) {
-			PERR("No se pudo agregar fsc");
-			return EMUFS_NOT_FOUND;
-		}
 
 	/* Encontró espacio en un bloque existente, graba registro ahí */
 	} else {
@@ -419,7 +439,7 @@ int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count)
 void emufs_tipo1_escribir_reg_en_memoria(char* dst, EMUFS_TIPO1_REG_HEADER header,
 		char* reg)
 {
-	return emufs_tipo1_escribir_reg_chunk_en_memoria(dst, header, reg, header.size);
+	emufs_tipo1_escribir_reg_chunk_en_memoria(dst, header, reg, header.size);
 }
 
 void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst,