*/
#include "emufs.h"
+#include "common.h"
#include "tipo1.h"
+#include "tipo2.h"
#include "tipo3.h"
#include "did.h"
#include "fsc.h"
return 0;
}
-
-EMUFS *emufs_crear(const char *filename, char tipo, unsigned long tam_bloque, unsigned long 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 *efs;
+ int err = 0;
- /* Si no es un tipo conocido, sale */
+ /* 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);
/* Abre archivo de datos. */
}
/* Guarda cabecera común. */
- fwrite(&tipo, sizeof(char), 1, fp); /* FIXME no debería ser sizeof(EMUFS_TYPE) ? */
+ 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;
case T1:
/* Asigna punteros a funciones. */
- efs->leer_bloque = emufs_tipo1_leer_bloque;
- efs->leer_registro = emufs_tipo1_leer_registro;
- efs->grabar_registro = emufs_tipo1_grabar_registro;
- efs->borrar_registro = emufs_tipo1_borrar_registro;
+ 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(unsigned long), 1, fp);
+ 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_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(unsigned int), 1, fp);
- fwrite(&tam_reg, sizeof(unsigned int), 1, fp);
-
+ fwrite(&tam_bloque, sizeof(EMUFS_BLOCK_SIZE), 1, fp);
+ fwrite(&tam_reg, sizeof(EMUFS_REG_SIZE), 1, fp);
break;
}
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, ".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 = emufs_tipo3_leer_bloque;
- tmp->leer_registro = emufs_tipo3_leer_registro;
- tmp->grabar_registro = emufs_tipo3_grabar_registro;
- tmp->borrar_registro = emufs_tipo3_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)
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");
{
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)) {
- printf("ID %ld en bloque %d\n", r.id_reg, r.block);
- 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;
+}
+
projects / z.facultad / 75.06 / emufs.git / blobdiff