X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/f3a31266bd5ccd4391c104619ec1ebc79b48519f..3b1230d10dade60af8e3eb544efb66cce69719b4:/emufs/tipo1.c diff --git a/emufs/tipo1.c b/emufs/tipo1.c index fbebc53..fa1c012 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -39,9 +39,9 @@ #include "idx.h" #include "fsc.h" #include "did.h" +#include "common.h" #include "error.h" #include -#include #include #include #include @@ -75,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) @@ -102,16 +99,26 @@ int emufs_tipo1_inicializar(EMUFS* efs) return EMUFS_OK; } -void* emufs_tipo1_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, +void* emufs_tipo1_leer_registro(EMUFS* efs, CLAVE clave, EMUFS_REG_SIZE* reg_size, int *err) { 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; /* offset del bloque leído */ + EMUFS_REG_ID reg_id; EMUFS_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */ - - block_id = emufs_idx_buscar_registro(efs, reg_id); + INDICE_DATO dato; + + if (efs->indices != NULL) { + /* TODO : Verificar donde esta el indice primario */ + dato = efs->indices->existe_entrada(efs->indices, clave); + block_id = dato.bloque; + reg_id = dato.id; + } else { + reg_id = clave.i_clave; + block_id = emufs_idx_buscar_registro(efs, reg_id); + } if (block_id == EMUFS_NOT_FOUND) { PERR("Registro no encontrado"); *err = EMUFS_NOT_FOUND; @@ -180,14 +187,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) { - char *chunk_ptr; 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_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) { @@ -196,7 +200,6 @@ void* emufs_tipo1_leer_registro_raw(EMUFS *efs, EMUFS_REG_ID id, EMUFS_REG_SIZE *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; @@ -208,45 +211,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. */ - 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) { - /* 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); - 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) @@ -269,10 +250,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; + fclose(file); 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; @@ -295,6 +278,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, EMUFS_BLOCK_ID curr_block_id; /* tamaño de la porción de registro que se guarda */ EMUFS_REG_SIZE chunk_size = 0; + INDICE_DATO idx_data; /* obtengo identificador que corresponderá al registro */ header.id = emufs_idx_get_new_id(efs, err); @@ -341,6 +325,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); + /* 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); @@ -371,23 +359,38 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg, PERR("No se pudo agregar idx"); return EMUFS_NOT_FOUND; } + idx_data.id = header.id; + idx_data.bloque = block_id; + emufs_indice_agregar(efs->indices, reg, idx_data); return header.id; } -int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) +int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k) { 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_TIPO1_REG_HEADER curr_reg_header; /* cabecera del registro a leer */ + EMUFS_REG_ID reg_id; + INDICE_DATO dato; int err = 0; /* para almacenar código de error */ - block_id = emufs_idx_buscar_registro(efs, reg_id); - if (block_id == EMUFS_NOT_FOUND) { - PERR("Registro no encontrado"); - return EMUFS_NOT_FOUND; + if (efs->indices != NULL) { + dato = efs->indices->existe_entrada(efs->indices, k); + block_id = dato.bloque; /*emufs_idx_buscar_registro(emu, ID);*/ + reg_id = dato.id; + } else { + reg_id = k.i_clave; + block_id = emufs_idx_buscar_registro(efs, reg_id); + if (block_id == EMUFS_NOT_FOUND) { + PERR("Registro no encontrado"); + return EMUFS_NOT_FOUND; + } } + + if (reg_id == -1) return EMUFS_NOT_FOUND; + if (!(block = (char*) emufs_tipo1_leer_bloque(efs, block_id, &err))) { PERR("no se pudo reservar memoria"); return err; @@ -404,12 +407,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); - EMUFS_FREE fs; /* cantidad de espacio libre en el bloque */ + /* cantidad de espacio libre original del ultimo bloque */ + EMUFS_FREE orig_fs; 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 */ - 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"); @@ -453,8 +458,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 */ + /* 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); + /* 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) */ @@ -478,43 +489,61 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, EMUFS_REG_ID reg_id) 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) { - 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; } void emufs_tipo1_compactar(EMUFS* efs) { +#ifdef ARREGLAR EMUFS_BLOCK_SIZE block_space /* tamaño para datos de un bloque */ = efs->tam_bloque - sizeof(EMUFS_TIPO1_REG_HEADER); EMUFS_REG_ID total_ids; /* cantidad total de registros en el array */ @@ -578,6 +607,7 @@ void emufs_tipo1_compactar(EMUFS* efs) emufs_fsc_truncate(efs, block_id); } } +#endif } EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, @@ -585,10 +615,20 @@ 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); @@ -654,10 +694,10 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block, return block_id; } -EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, EMUFS_REG_ID id, +EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k, void *data, EMUFS_REG_SIZE size, int* err) { - emufs_tipo1_borrar_registro(efs, id); + emufs_tipo1_borrar_registro(efs, k); return emufs_tipo1_grabar_registro(efs, data, size, err); } @@ -695,24 +735,6 @@ 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) -{ - 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) { - PERR("Error al abrir archivo"); - *err = EMUFS_ERROR_CANT_OPEN_FILE; - return 0; - } - file_size = ftell(file); - fclose(file); - return file_size; -} - 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) { int err = 0; @@ -721,4 +743,3 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c (*siguiente) = emufs_tipo1_leer_bloque(efs, id+1, &err); (*size1) = (*size2) = (*size3) = efs->tam_bloque; } -