X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/60505ae8ce77483ea58c6829c20de89f1c01afaf..224194e18dce492ec2df32c6dd1f3b8d7290b4be:/emufs/emufs.c?ds=sidebyside diff --git a/emufs/emufs.c b/emufs/emufs.c index 698f955..76260ac 100644 --- a/emufs/emufs.c +++ b/emufs/emufs.c @@ -1,11 +1,51 @@ +/* vim: set noexpandtab tabstop=4 shiftwidth=4: + *---------------------------------------------------------------------------- + * emufs + *---------------------------------------------------------------------------- + * This file is part of emufs. + * + * emufs is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License as published by the Free Software + * Foundation; either version 2 of the License, or (at your option) any later + * version. + * + * emufs is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along + * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple + * Place, Suite 330, Boston, MA 02111-1307 USA + *---------------------------------------------------------------------------- + * Creado: mié mar 31 17:26:46 ART 2004 + * Autores: Nicolás Dimov + * Ricardo Markiewicz + * Leandro Lucarella + *---------------------------------------------------------------------------- + * + * $Id$ + * + */ + +/** \file + * + * Estructura general de un archivo abstracto de emufs. + * + * Implementación de la estructura abstracta que representa cualquiera de los + * tipos de archivo implementados. Se incluyen funciones tipo factory + * para crear un archivo, abrirlo y destruirlo. + * + */ + #include "emufs.h" +#include "common.h" +#include "tipo1.h" +#include "tipo2.h" #include "tipo3.h" - -/* Defino las extenciones que usan cada tipo de archivo */ -#define EXT_TIPO3_ID ".idx" -#define EXT_TIPO3_DATA ".dat" -#define EXT_TIPO3_DISP ".fsc" -#define EXT_TIPO3_IDS ".did" +#include "did.h" +#include "fsc.h" +#include "idx.h" char *str_dup(const char *s); @@ -18,108 +58,213 @@ char *str_dup(const char *s) return tmp; } +int emufs_crear_archivo_auxiliar(const char* name, const char* ext) +{ + FILE* f; + char* filename; + + filename = (char*) malloc(sizeof(char) * (strlen(name) + strlen(ext) + 1)); + if (filename == NULL) { + /* TODO Manejo de errores */ + return -1; + } + strcpy(filename, name); + strcat(filename, ext); + f = fopen(filename, "w"); + free(filename); + if (f == NULL) { + /* TODO Manejo de errores */ + return -1; + } + fclose(f); + return 0; +} -EMUFS *emufs_crear(const char *filename, char tipo, unsigned int tam_bloque, unsigned int tam_reg) +EMUFS *emufs_crear(const char *filename, EMUFS_Tipo tipo, EMUFS_BLOCK_SIZE tam_bloque, EMUFS_REG_SIZE tam_reg) { char name[255]; FILE *fp; - EMUFS *tmp = (EMUFS *)malloc(sizeof(EMUFS)); + EMUFS *efs; + int err = 0; + + /* Si no es un tipo conocido, sale. */ + if ((tipo != T1) && (tipo != T2) && (tipo != T3)) { + return NULL; + } + + /* Inicializa parámetros comunes. */ + efs = (EMUFS*) malloc(sizeof(EMUFS)); + if (efs == NULL) { + return NULL; + } + efs->tipo = tipo; + efs->tam_bloque = tam_bloque; + efs->tam_reg = tam_reg; + efs->nombre = str_dup(filename); + efs->indices = NULL; + + /* Abre archivo de datos. */ + strcpy(name, filename); + strcat(name, ".dat"); + fp = fopen(name, "w"); + if (fp == NULL) { + /* TODO ERROR */ + free(efs->nombre); + free(efs); + return NULL; + } + + /* Guarda cabecera común. */ + 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; + } + + /* Crea archivo de control de espacio libre. */ + if (emufs_fsc_crear(efs)) { + /* TODO ERROR */ + fclose(fp); + free(efs->nombre); + free(efs); + return NULL; + } + + /* Crea archivo de identificadores borrados (recuperables). */ + if (emufs_did_crear(efs)) { + /* TODO ERROR */ + fclose(fp); + free(efs->nombre); + free(efs); + return NULL; + } + + /* Termina de realizar el trabajo según el tipo de archivo. */ switch (tipo) { + case T1: - break; - case T2: - break; - case T3: - tmp->tipo = T3; - tmp->tam_bloque = tam_bloque; - tmp->leer_bloque = leer_bloque; - tmp->leer_registro = leer_registro; - tmp->grabar_registro = grabar_registro; - tmp->borrar_registro = borrar_registro; - tmp->nombre = str_dup(filename); - - strcpy(name, filename); - strcat(name, EXT_TIPO3_DATA); - fp = fopen(name, "w"); - if (fp == NULL) { - /* ERROR */ - free(tmp->nombre); - free(tmp); + /* 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; } - /* Guardo el Header */ - fwrite(&tipo, sizeof(char), 1, fp); - fwrite(&tam_bloque, sizeof(unsigned int), 1, fp); - fwrite(&tam_reg, sizeof(unsigned int), 1, fp); - fclose(fp); - - strcpy(name, filename); - strcat(name, EXT_TIPO3_ID); - fp = fopen(name, "w"); - fclose(fp); - - strcpy(name, filename); - strcat(name, EXT_TIPO3_DISP); - fp = fopen(name, "w"); - fclose(fp); - - strcpy(name, filename); - strcat(name, EXT_TIPO3_IDS); - fp = fopen(name, "w"); - fclose(fp); - - break; - default: - free(tmp); - return NULL; + + /* Guarda cabeceras propias. */ + fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp); + + break; + + case T2: + /* Asigna punteros a funciones. */ + 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_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); + break; + } - return tmp; + fclose(fp); + return efs; } EMUFS *emufs_abrir(const char *filename) { - EMUFS *tmp; + EMUFS *efs; char name[255]; char tipo; FILE *fp; + int err = 0; strcpy(name, filename); - strcat(name, EXT_TIPO3_DATA); + strcat(name, ".dat"); /* Trato de determinar el tipo de archivo */ fp = fopen(name, "r"); if (fp == NULL) return NULL; - fread(&tipo, sizeof(char), 1, fp); - if ((tipo < 0) || (tipo > 2)) { + fread(&tipo, sizeof(EMUFS_Tipo), 1, fp); + + /* Si no es un tipo conocido, sale. */ + if ((tipo != T1) && (tipo != T2) && (tipo != T3)) { fclose(fp); return NULL; } - tmp = (EMUFS *)malloc(sizeof(EMUFS)); - if (tmp == NULL) { + /* Inicializa parámetros comunes. */ + efs = (EMUFS*) malloc(sizeof(EMUFS)); + if (efs == NULL) { fclose(fp); return NULL; } - + efs->tipo = tipo; + efs->nombre = str_dup(filename); + switch (tipo) { case T1: - break; + /* Lee cabeceras propias. */ + if (!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) { + free(efs->nombre); + free(efs); + 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: - break; + /* Asigna punteros a funciones. */ + emufs_tipo2_inicializar(efs); + break; case T3: - tmp->tipo = tipo; - fread(&tmp->tam_bloque, sizeof(int), 1, fp); - tmp->leer_bloque = leer_bloque; - tmp->leer_registro = leer_registro; - tmp->grabar_registro = grabar_registro; - tmp->borrar_registro = borrar_registro; - tmp->nombre = str_dup(filename); + if ((!fread(&(efs->tam_bloque), sizeof(EMUFS_BLOCK_SIZE), 1, fp)) || + (!fread(&(efs->tam_reg), sizeof(EMUFS_REG_SIZE), 1, fp))) + { + free(efs->nombre); + free(efs); + 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->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; } fclose(fp); - return tmp; + return efs; } int emufs_destruir(EMUFS *e) @@ -133,38 +278,130 @@ int emufs_destruir(EMUFS *e) int ver_archivo_FS(EMUFS *emu) { FILE *f_block_free; - BLOCK_FREE_T reg; + EMUFS_FSC reg; char name_f_block_free[255]; strcpy(name_f_block_free,emu->nombre); 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) ){ - printf(" Bloque = %d Espacio libre = %d\n",reg.block, reg.free_space); + fprintf(stderr, "Bloque = %li Espacio libre = %li\n",reg.marker, reg.freespace); fread(®,sizeof(reg),1,f_block_free); } fclose(f_block_free); /* Imprimo la lista de bloques/registros */ + 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"); { - BLOCK_REG_T r; - f_block_free = fopen(name_f_block_free, "r"); - fread(&r, sizeof(BLOCK_REG_T), 1, f_block_free); + EMUFS_IDX r; while (!feof(f_block_free)) { - printf("ID %ld en bloque %d\n", r.id_reg, r.block); - fread(&r, sizeof(BLOCK_REG_T), 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; + } + } + + 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); + + if (tmp == NULL) 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, CLAVE clave, int *cant) +{ + INDICE *tmp; + tmp = emu->indices; + while (tmp) { + if (strcmp(tmp->nombre, indice) == 0) break; + } + + if (tmp == NULL) { + PERR("NO EXISTE EL INDICE"); + cant = 0; + return NULL; + } + + return tmp->buscar_entradas(tmp, clave, cant); +} +