X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/9becab83c083dd57876b1d29ec4bc73cbda912ac..f00458382f8b687eeef68f9f5fe9e9245a4d5fb5:/emufs/tipo1.c diff --git a/emufs/tipo1.c b/emufs/tipo1.c index eeaef09..9d1cd04 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -39,11 +39,13 @@ #include "idx.h" #include "fsc.h" #include "did.h" +#include "common.h" +#include "error.h" +#include #include #include #include #include -#include #ifndef MIN # define MIN(x, y) (((x) > (y)) ? (y) : (x)) @@ -73,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*); -/** Obtiene el tamaño del archivo. */ -static long emufs_tipo1_get_file_size(EMUFS*, int*); - /*------------------ Funciones públicas ----------------------*/ int emufs_tipo1_inicializar(EMUFS* efs) @@ -85,17 +84,19 @@ int emufs_tipo1_inicializar(EMUFS* efs) * mala */ if (efs->tam_bloque < (sizeof(EMUFS_TIPO1_REG_HEADER) * 2)) { PERR("bloque demasiado chico"); - return 1000; /* EMUFS_ERROR_BLOCK_SIZE_TOO_SMALL */ + return EMUFS_ERROR_BLOCK_TOO_SMALL; } /* Asigna punteros a funciones. */ efs->leer_bloque = emufs_tipo1_leer_bloque; + efs->leer_bloque_raw = emufs_tipo1_leer_bloque_raw; efs->grabar_registro = emufs_tipo1_grabar_registro; efs->borrar_registro = emufs_tipo1_borrar_registro; efs->leer_registro = emufs_tipo1_leer_registro; efs->leer_registro_raw = emufs_tipo1_leer_registro_raw; efs->leer_estadisticas = emufs_tipo1_leer_estadisticas; efs->compactar = emufs_tipo1_compactar; - return 0; /* EMUFS_OK */ + efs->tam_reg = 0; + return EMUFS_OK; } void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, @@ -109,15 +110,13 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, block_id = emufs_idx_buscar_registro(efs, reg_id); if (block_id == EMUFS_NOT_FOUND) { - /* TODO Manejo de errores */ PERR("Registro no encontrado"); *err = EMUFS_NOT_FOUND; return NULL; } if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) { - /* TODO Manejo de errores */ PERR("no se pudo reservar memoria"); - *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */ + *err = EMUFS_ERROR_OUT_OF_MEMORY; return NULL; } @@ -139,10 +138,9 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, *reg_size = curr_reg_header.size; 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 */ + *err = EMUFS_ERROR_OUT_OF_MEMORY; return NULL; } while (1) { @@ -156,10 +154,9 @@ void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, 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 */ + *err = EMUFS_ERROR_OUT_OF_MEMORY; return NULL; } } else { /* se terminó de leer */ @@ -187,11 +184,10 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE EMUFS_BLOCK_SIZE offset, block_space; /* offset del bloque leído */ EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */ EMUFS_REG_SIZE cant_bloques; - int err, i; + int err = 0, i; block_id = emufs_idx_buscar_registro(efs, id); if (block_id == EMUFS_NOT_FOUND) { - /* TODO Manejo de errores */ PERR("Registro no encontrado"); *pos = 0; *size = 0; @@ -199,17 +195,16 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE } err = 0; if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) { - /* TODO Manejo de errores */ PERR("no se pudo reservar memoria"); *pos = 0; *size = 0; return NULL; } - /* Busco secuencialmente en el bloque el registro a leer */ + /* busco secuencialmente en el bloque el registro a leer */ offset = 0; do { - /* Copio la cabecera del registro actual. */ + /* copio la cabecera del registro actual. */ memcpy(&curr_reg_header, block + offset, sizeof(EMUFS_TIPO1_REG_HEADER)); offset += sizeof(EMUFS_TIPO1_REG_HEADER); if (curr_reg_header.id == id) { @@ -222,7 +217,6 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *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) { - /* TODO Manejo de errores */ free(block); PERR("No hay memoria"); *pos = 0; @@ -231,9 +225,9 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE } memcpy(registro, block, efs->tam_bloque); chunk_ptr += efs->tam_bloque; - /* Copio los otros bloques, si los hay */ + /* copio los otros bloques, si los hay */ free(block); - for(i=1; itam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER); free(block); } - /* Todo listo! */ - break; + break; /* se terminó el trabajo. */ } /* Desplazo el offset */ offset += curr_reg_header.size; @@ -253,7 +246,7 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE return registro; } -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) { FILE* file; char* block; /* bloque leido (en donde está el registro a leer) */ @@ -264,24 +257,21 @@ void* emufs_tipo1_leer_bloque(EMUFS* efs, EMUFS_BLOCK_ID block_id, int *err) if ((file = fopen(name_f, "r")) == NULL) { PERR("No se puede abrir archivo"); - *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */ - return NULL; /* FIXME ERROR */ + *err = EMUFS_ERROR_CANT_OPEN_FILE; + return NULL; } emufs_tipo1_header_jump(file); /* salta cabeceras */ emufs_tipo1_block_jump(efs, file, block_id); /* salta bloques */ - /* FIXME: verificar que no se pase de fin de archivo*/ block = (char*) malloc(efs->tam_bloque); if (block == NULL) { - /* TODO Manejo de errores */ PERR("No hay memoria"); - *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */ + *err = EMUFS_ERROR_OUT_OF_MEMORY; return NULL; } if (fread(block, efs->tam_bloque, 1, file) != 1) { - /* TODO Manejo de errores */ free(block); PERR("Error al leer bloque"); - *err = 3; /* EMUFS_ERROR_FILE_READ */ + *err = EMUFS_ERROR_FILE_READ; return NULL; } fclose(file); @@ -323,9 +313,8 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, /* crear un nuevo bloque en memoria */ block = (char*) malloc(efs->tam_bloque); if (block == NULL) { - /* TODO Manejo de errores */ PERR("No hay memoria"); - *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */ + *err = EMUFS_ERROR_OUT_OF_MEMORY; return EMUFS_NOT_FOUND; } memset(block, 0, efs->tam_bloque); /* inicializa bloque */ @@ -334,7 +323,6 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, } else { /* cargo el bloque en block_id */ if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, err))) { - /* TODO Manejo de errores */ PERR("no se pudo leer el bloque"); return EMUFS_NOT_FOUND; } @@ -394,12 +382,10 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) block_id = emufs_idx_buscar_registro(efs, reg_id); if (block_id == EMUFS_NOT_FOUND) { - /* TODO Manejo de errores */ PERR("Registro no encontrado"); return EMUFS_NOT_FOUND; } if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) { - /* TODO Manejo de errores */ PERR("no se pudo reservar memoria"); return err; } @@ -423,7 +409,6 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) + MIN(curr_reg_header.size, block_space) + sizeof(EMUFS_TIPO1_REG_HEADER); if ((err = emufs_fsc_actualizar(efs, curr_block_id, fs))) { - /* TODO Manejo de errores */ PERR("no se pudo actualizar .fsc"); free(block); return err; @@ -433,7 +418,6 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) free(block); if (!(block = (char*) emufs_tipo1_leer_bloque(efs, ++curr_block_id, &err))) { - /* TODO Manejo de errores */ PERR("no se pudo leer el bloque"); return err; } @@ -448,14 +432,12 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) /* actualizo archivo de identificadores de registros borrados */ if ((err = emufs_did_agregar(efs, reg_id))) { - /* TODO Manejo de errores */ PERR("no se pudo actualizar .did"); free(block); return err; } /*actualizo archivo .idx*/ if ((err = emufs_idx_borrar(efs, reg_id))) { - /* TODO Manejo de errores */ PERR("no se pudo actualizar .did"); free(block); return err; @@ -476,13 +458,12 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) emufs_tipo1_grabar_bloque_fsc(efs, block, curr_block_id, EMUFS_NOT_FOUND, &err); if (err) { - /* TODO Manejo de errores */ PERR("no se pudo grabar bloque en disco"); free(block); return err; } - break; /* salgo del loop, ya hice todo lo que tenía que hacer */ + break; /* salgo del loop, ya terminé lo que tenía que hacer */ } /* desplazo el offset */ offset += sizeof(EMUFS_TIPO1_REG_HEADER) + curr_reg_header.size; @@ -491,41 +472,57 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) } while (offset < efs->tam_bloque); /* registro está en el bloque */ free(block); - return 0; /* 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)); - stats.tam_archivo_bytes = emufs_tipo1_get_file_size(efs, &err); - if (err) { - /* TODO manejo de errores */ - 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 */ { - 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 */ } - /* 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 */ - + 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 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; } @@ -602,18 +599,27 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, { 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 */ - 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; + if (*err) { + PERR("Error al obtener tamaño del archivo."); + return EMUFS_NOT_FOUND; + } /* abre archivo */ strcpy(name_f,efs->nombre); strcat(name_f,".dat"); if ((file = fopen(name_f, "r+b")) == NULL) { - /* TODO Manejo de errores */ PERR("Error al abrir archivo"); - *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */ + *err = EMUFS_ERROR_CANT_OPEN_FILE; return EMUFS_NOT_FOUND; } /* Si es NOT_FOUND o mayor a la cantidad de bloques presentes, @@ -621,10 +627,9 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, if ((block_id == EMUFS_NOT_FOUND) || (block_id >= num_blocks)) { /* me paro al final del archivo */ if (fseek(file, 0l, SEEK_END)) { - /* TODO Manejo de errores */ PERR("No se pudo hacer fseek()"); fclose(file); - *err = 8; /* EMUFS_ERROR_SEEK_FILE */ + *err = EMUFS_ERROR_SEEK_FILE; return EMUFS_NOT_FOUND; } /* Obtengo ID del bloque nuevo */ @@ -655,7 +660,6 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, /* si me lo solicitan, actualizo el .fsc */ if (fs != EMUFS_NOT_FOUND) { if ((*err = emufs_fsc_actualizar(efs, block_id, fs))) { - /* TODO Manejo de errores */ PERR("no se pudo actualizar .fsc"); fclose(file); return EMUFS_NOT_FOUND; @@ -666,7 +670,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, if (fwrite(block, efs->tam_bloque, 1, file) != 1) { PERR("No se pudo escribir el archivo"); fclose(file); - *err = 6; /* EMUFS_ERROR_WRITE_FILE */ + *err = EMUFS_ERROR_WRITE_FILE; return EMUFS_NOT_FOUND; } @@ -674,11 +678,11 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, return block_id; } -EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, - void *data, EMUFS_REG_SIZE size, int *error) +EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, EMUFS_REG_ID id, + void *data, EMUFS_REG_SIZE size, int* err) { - emufs_tipo1_borrar_registro(emu, id); - return emufs_tipo1_grabar_registro(emu, data, size, error); + emufs_tipo1_borrar_registro(efs, id); + return emufs_tipo1_grabar_registro(efs, data, size, err); } size_t emufs_tipo1_header_size(void) @@ -690,18 +694,18 @@ int emufs_tipo1_header_jump(FILE* fp) { if (fseek(fp, emufs_tipo1_header_size(), SEEK_CUR)) { PERR("No se pudo hacer fseek()"); - return 8; /* EMUFS_ERROR_SEEK_FILE */ + return EMUFS_ERROR_SEEK_FILE; } - return 0; /* EMUFS_OK */ + return EMUFS_OK; } int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count) { if (fseek(fp, block_count * efs->tam_bloque, SEEK_CUR)) { PERR("No se pudo hacer fseek()"); - return 8; /* EMUFS_ERROR_SEEK_FILE */ + return EMUFS_ERROR_SEEK_FILE; } - return 0; /* EMUFS_OK */ + return EMUFS_OK; } void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst, @@ -715,22 +719,11 @@ void emufs_tipo1_escribir_reg_chunk_en_memoria(char* dst, memcpy(dst, reg, reg_size); } -long emufs_tipo1_get_file_size(EMUFS* efs, int* err) +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) { - 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) { - /* TODO Manejo de errores */ - PERR("Error al abrir archivo"); - *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */ - return 0; - } - file_size = ftell(file); - fclose(file); - return file_size; + int err = 0; + (*actual) = emufs_tipo1_leer_bloque(efs, id, &err); + (*anterior) = emufs_tipo1_leer_bloque(efs, id-1, &err); + (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err); + (*size1) = (*size2) = (*size3) = efs->tam_bloque; } -