X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/3579dcf7da4edf3ba729e1d71fbe91d1e1f0b5ad..d718803ef7f9e17b2fb893ea9c7c2905a1591cf2:/emufs/emufs.c?ds=inline diff --git a/emufs/emufs.c b/emufs/emufs.c index 8f68f82..fc4165d 100644 --- a/emufs/emufs.c +++ b/emufs/emufs.c @@ -39,6 +39,7 @@ */ #include "emufs.h" +#include "common.h" #include "tipo1.h" #include "tipo2.h" #include "tipo3.h" @@ -46,6 +47,17 @@ #include "fsc.h" #include "idx.h" +typedef struct _data_indices_ { + char nombre[50]; + INDICE_FUNCION funcion; + INDICE_TIPO tipo; + INDICE_TIPO_DATO tipo_dato; + unsigned int offset; + unsigned int tam_bloque; +} t_Indice; + +int guardar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque); + char *str_dup(const char *s); char *str_dup(const char *s) @@ -79,11 +91,12 @@ int emufs_crear_archivo_auxiliar(const char* name, const char* ext) return 0; } -EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg) +EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg) { - char name[255]; + char name[255], otroname[255]; FILE *fp; EMUFS *efs; + int err = 0; /* Si no es un tipo conocido, sale. */ if ((tipo != T1) && (tipo != T2) && (tipo != T3)) { @@ -99,6 +112,17 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b efs->tam_bloque = tam_bloque; efs->tam_reg = tam_reg; efs->nombre = str_dup(filename); + efs->indices = NULL; + + sprintf(otroname, "%s.info", efs->nombre); + fp = fopen(otroname, "w"); + if (fp == NULL) { + PERR("CARAJO!, NO PUEDO CREAR INFO"); + } else { + err = 0; + fwrite(&err, 1, sizeof(int), fp); + fclose(fp); + } /* Abre archivo de datos. */ strcpy(name, filename); @@ -112,11 +136,12 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b } /* Guarda cabecera común. */ - fwrite(&tipo, sizeof(EMUFS_TYPE), 1, fp); + fwrite(&tipo, sizeof(EMUFS_Tipo), 1, fp); /* Crea archivo de índice. */ if (emufs_idx_crear(efs)) { /* TODO ERROR */ + fclose(fp); free(efs->nombre); free(efs); return NULL; @@ -125,6 +150,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b /* Crea archivo de control de espacio libre. */ if (emufs_fsc_crear(efs)) { /* TODO ERROR */ + fclose(fp); free(efs->nombre); free(efs); return NULL; @@ -133,6 +159,7 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b /* Crea archivo de identificadores borrados (recuperables). */ if (emufs_did_crear(efs)) { /* TODO ERROR */ + fclose(fp); free(efs->nombre); free(efs); return NULL; @@ -142,7 +169,15 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b switch (tipo) { case T1: - emufs_tipo1_inicializar(efs); + /* Asigna punteros a funciones. */ + if ((err = emufs_tipo1_inicializar(efs))) { + /* TODO ERROR */ + PERR("No se pudo inicializar el EMUFS de tipo1"); + fclose(fp); + free(efs->nombre); + free(efs); + return NULL; + } /* Guarda cabeceras propias. */ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp); @@ -151,19 +186,20 @@ EMUFS *emufs_crear(const char *filename, EMUFS_TYPE tipo, EMUFS_BLOCK_SIZE tam_b case T2: /* Asigna punteros a funciones. */ - efs->grabar_registro = emufs_tipo2_grabar_registro; - efs->borrar_registro = emufs_tipo2_borrar_registro; - efs->nombre = str_dup(filename); - /*efs->leer_registro = emufs_tipo2_leer_registro;*/ + emufs_tipo2_inicializar(efs); break; case T3: /* Asigna punteros a funciones. */ - efs->leer_bloque = emufs_tipo3_leer_bloque; - efs->leer_registro = emufs_tipo3_leer_registro; + efs->leer_bloque = emufs_tipo3_leer_bloque; + efs->leer_registro = emufs_tipo3_leer_registro; + efs->leer_registro_raw = emufs_tipo3_leer_registro_raw; efs->grabar_registro = emufs_tipo3_grabar_registro; efs->borrar_registro = emufs_tipo3_borrar_registro; - + efs->leer_estadisticas = emufs_tipo3_leer_estadisticas; + efs->modificar_registro = emufs_tipo3_modificar_registro; + efs->compactar = emufs_tipo3_compactar; + efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw; /* Guarda cabeceras propias. */ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp); fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp); @@ -181,6 +217,7 @@ EMUFS *emufs_abrir(const char *filename) char name[255]; char tipo; FILE *fp; + int err = 0; strcpy(name, filename); strcat(name, ".dat"); @@ -188,7 +225,7 @@ EMUFS *emufs_abrir(const char *filename) /* Trato de determinar el tipo de archivo */ fp = fopen(name, "r"); if (fp == NULL) return NULL; - fread(&tipo, sizeof(EMUFS_TYPE), 1, fp); + fread(&tipo, sizeof(EMUFS_Tipo), 1, fp); /* Si no es un tipo conocido, sale. */ if ((tipo != T1) && (tipo != T2) && (tipo != T3)) { @@ -204,10 +241,9 @@ EMUFS *emufs_abrir(const char *filename) } efs->tipo = tipo; efs->nombre = str_dup(filename); - + switch (tipo) { case T1: - emufs_tipo1_inicializar(efs); /* Lee cabeceras propias. */ if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) { free(efs->nombre); @@ -215,8 +251,16 @@ EMUFS *emufs_abrir(const char *filename) fclose(fp); return NULL; } + /* Asigna punteros a funciones. */ + if ((err = emufs_tipo1_inicializar(efs))) { + PERR("No se pudo inicializar el EMUFS de tipo1"); + fclose(fp); + return NULL; + } break; case T2: + /* Asigna punteros a funciones. */ + emufs_tipo2_inicializar(efs); break; case T3: if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) || @@ -227,10 +271,16 @@ EMUFS *emufs_abrir(const char *filename) fclose(fp); return NULL; } + /* Asigna punteros a funciones. */ efs->leer_bloque = emufs_tipo3_leer_bloque; + efs->leer_registro_raw = emufs_tipo3_leer_registro_raw; efs->leer_registro = emufs_tipo3_leer_registro; efs->grabar_registro = emufs_tipo3_grabar_registro; - /*efs->borrar_registro = emufs_tipo3_borrar_registro;*/ + efs->borrar_registro = emufs_tipo3_borrar_registro; + efs->leer_estadisticas = emufs_tipo3_leer_estadisticas; + efs->modificar_registro = emufs_tipo3_modificar_registro; + efs->compactar = emufs_tipo3_compactar; + efs->leer_bloque_raw = emufs_tipo3_leer_bloque_raw; break; } @@ -240,7 +290,18 @@ EMUFS *emufs_abrir(const char *filename) int emufs_destruir(EMUFS *e) { + INDICE *del, *cur; + if (e == NULL) return 1; + + /* libero indices */ + cur = e->indices; + while (cur) { + del = cur; + cur = cur->sig; + emufs_indice_destruir(e, cur); + } + free(e->nombre); free(e); return 0; @@ -256,12 +317,13 @@ int ver_archivo_FS(EMUFS *emu) strcat(name_f_block_free,".fsc"); if ( (f_block_free = fopen(name_f_block_free,"r"))==NULL ){ - printf("no pude abrir el archivo %s\n",name_f_block_free); + fprintf(stderr, "no pude abrir el archivo %s\n",name_f_block_free); return -1; } + fprintf(stderr,"BOQUES Y ESPACIO LIBRE\n"); fread(®,sizeof(reg),1,f_block_free); while ( !feof(f_block_free) ){ - fprintf(stderr, " Bloque = %li Espacio libre = %li\n",reg.n_marker, reg.n_freespace); + fprintf(stderr, "Bloque = %li Espacio libre = %li\n",reg.marker, reg.freespace); fread(®,sizeof(reg),1,f_block_free); } @@ -271,17 +333,232 @@ int ver_archivo_FS(EMUFS *emu) fprintf(stderr, "BLOQUES Y REGISTROS\n"); strcpy(name_f_block_free,emu->nombre); strcat(name_f_block_free,".idx"); + f_block_free = fopen(name_f_block_free, "r"); { EMUFS_IDX r; - f_block_free = fopen(name_f_block_free, "r"); - fread(&r, sizeof(EMUFS_IDX), 1, f_block_free); while (!feof(f_block_free)) { - fprintf(stderr, "ID %li en bloque %li\n", r.n_idreg, r.n_location); - fread(&r, sizeof(EMUFS_IDX), 1, f_block_free); + if (fread(&r, sizeof(EMUFS_IDX), 1, f_block_free) != 1) continue; + fprintf(stderr, "ID %li en bloque %li\n", r.id_reg, r.location); } - fclose(f_block_free); } - + fclose(f_block_free); return 0; } + +int debug_ver_estadisticas(EMUFS* efs) +{ + EMUFS_Estadisticas s = efs->leer_estadisticas(efs); + + printf("ESTADISTICAS:\n"); + printf("=============\n"); + printf("Tamaño del archivo: %lu bytes\n", s.tam_archivo); + printf("Tamaño de datos (incluye espacio libre): %lu bytes (%.2f %%)\n", + s.tam_archivo - s.tam_info_control_dat, + (s.tam_archivo - s.tam_info_control_dat) * 100.0 + / (float) s.tam_archivo); + printf("Tamaño de info de control total: %lu bytes (%.2f %%)\n", + s.tam_info_control_dat + s.tam_archivos_aux, + (s.tam_info_control_dat + s.tam_archivos_aux) * 100.0 + / (float) s.tam_archivo); + printf("Tamaño de los archivos auxiliares: %lu bytes\n", + s.tam_archivos_aux); + printf("Tamaño de la información de control en el .dat: %lu bytes\n", + s.tam_info_control_dat); + printf("Total de espacio libre: %lu bytes\n", s.total_fs); + printf("Máximo espacio libre en bloque: %lu bytes\n", s.max_fs); + printf("Mínimo espacio libre en bloque: %lu bytes\n", s.min_fs); + printf("Media del espacio libre por bloque: %lu bytes\n", s.media_fs); + printf("Cantidad de registros: %lu\n", s.cant_registros); + printf("Cantidad de bloques: %lu\n", s.cant_bloques); + return 0; +} + +int emufs_agregar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque) +{ + INDICE *tmp; + int error=0; + + /* Verifico que no existe un indice con el mismo nombre */ + /* y que no exista un indice primario */ + PERR("Agregando indice"); + tmp = emu->indices; + while (tmp) { + if (strcmp(tmp->nombre, nombre)==0) { + error = 1; + break; + } + if ((funcion == IND_PRIMARIO) && (tmp->funcion == funcion)) { + error = 2; + break; + } + tmp = tmp->sig; + } + + if (tmp != NULL) { + switch (error) { + case 1: + PERR("Ya existe un indice con el mismo nombre!"); + break; + case 2: + PERR("EMUFS ya tiene indice primario!!"); + } + return 0; + } + + /* Creo el nuevo indice */ + PERR("Creando indice\n"); + tmp = emufs_indice_crear(emu, nombre, funcion, tipo, tipo_dato, offset, tam_bloque); + + /* Guardo la info del indice para poder abrir despues el archivo */ + guardar_indice(emu, nombre, funcion, tipo, tipo_dato, offset, tam_bloque); + + if (tmp == NULL) { + PERR("NO SE PUDO CREAR INDICE!!!"); + return 0; + } + + if (emu->indices==NULL) + emu->indices = tmp; + else { + tmp->sig = emu->indices; + emu->indices = tmp; + } + return 1; +} + +INDICE_DATO *emufs_buscar_registros(EMUFS *emu, char *indice, char *data, int *cant) +{ + CLAVE k; + INDICE *tmp; + + tmp = emu->indices; + while (tmp) { + if (strcmp(tmp->nombre, indice) == 0) break; + tmp = tmp->sig; + } + + if (tmp == NULL) { + PERR("NO EXISTE EL INDICE"); + cant = 0; + return NULL; + } + + PERR("GENERANDO CLAVE") + PERR(data); + k = emufs_indice_generar_clave_desde_valor(tmp, data); + PERR("DONE"); + return tmp->buscar_entradas(tmp, k, cant); +} + +int guardar_indice(EMUFS *emu, char *nombre, INDICE_FUNCION funcion, INDICE_TIPO tipo, INDICE_TIPO_DATO tipo_dato, unsigned int offset, unsigned int tam_bloque) +{ + char filename[100]; + FILE *fp; + int cant; /* cantidad de indices hasta el momento */ + t_Indice *indices; + + sprintf(filename, "%s.info", emu->nombre); + fp = fopen(filename, "r+"); + PERR("Abri info"); + PERR(filename); + if (fp == NULL) { + PERR("No se pudo"); + return 0; + } + + fread(&cant, 1, sizeof(int), fp); + indices = malloc((cant+1)*sizeof(t_Indice)); + fread(indices, cant, sizeof(t_Indice), fp); + memset(indices[cant].nombre, 0, 50); + strcpy(indices[cant].nombre, nombre); + indices[cant].funcion = funcion; + indices[cant].tipo = tipo; + indices[cant].tipo_dato = tipo_dato; + indices[cant].offset = offset; + indices[cant].tam_bloque = tam_bloque; + + fseek(fp, SEEK_SET, 0); + cant++; + fwrite(&cant, 1, sizeof(int), fp); + fwrite(indices, cant, sizeof(t_Indice), fp); + fclose(fp); + free(indices); + return 1; +} + +/*crea un bloque y devuelve en numero del mismo*/ +EMUFS_BLOCK_ID emufs_create_new_block(EMUFS *emu) +{ + FILE *fp; + char name[255]; + char *dummy; + EMUFS_BLOCK_ID num; + + /* obtengo nombre del archivo */ + strcpy(name, emu->nombre); + strcat(name,".dat"); + + if ( (fp=fopen(name,"a+")) == NULL ){ + PERR("NO SE PUDO ABRIR EL ARCHIVO"); + return -1; + } + + dummy = (char*)malloc(emu->tam_bloque); + memset(dummy, 0, emu->tam_bloque); + fwrite(dummy, emu->tam_bloque, 1, fp); +<<<<<<< .mine + fprintf(stderr, "new_block ftell = %ld\n", ftell(fp)); +======= +>>>>>>> .r552 + switch(emu->tipo){ + case T1: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE))/emu->tam_bloque; + break; + case T3: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/emu->tam_bloque; + } + fclose(fp); + free(dummy); + return num; +} + +/*devuelve un numero de bloque siguiente al ultimo*/ +EMUFS_BLOCK_ID emufs_get_new_block_number(EMUFS *emu) +{ + FILE *fp; + char name[255]; + EMUFS_BLOCK_ID num=0; + + /* obtengo nombre del archivo */ + strcpy(name, emu->nombre); + strcat(name,".dat"); + if ( (fp=fopen(name,"r")) == NULL ){ + PERR("NO SE PUDO ABRIR EL ARCHIVO"); + return -1; + } + if ( fseek(fp, 0, SEEK_END)!=0 ){ + PERR("NO PUDE HACER EL SEEK"); + return -1; + } + switch(emu->tipo){ + case T1: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE))/emu->tam_bloque; + if (ftell(fp) == sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)) num = 0; + PERR("PASE"); + break; + case T3: num = (ftell(fp)-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/emu->tam_bloque; + if (ftell(fp) == sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE)) num = 0; + } + fclose(fp); + return num; +} + +INDICE *emufs_buscar_indice_por_nombre(EMUFS *emu, const char *nombre) +{ + INDICE *tmp; + + tmp = emu->indices; + while (tmp) { + if (strcmp(tmp->nombre, nombre) == 0) break; + tmp = tmp->sig; + } + return tmp; +}