X-Git-Url: https://git.llucax.com/z.facultad/75.06/emufs.git/blobdiff_plain/6c5fe1e15e441c27ba01b22b91bf1e5843ae53f2..e71b2f6ba15c4035c6fb10526b4ffd29d44b0ba2:/emufs/fsc.c diff --git a/emufs/fsc.c b/emufs/fsc.c index c0c026f..84746a8 100644 --- a/emufs/fsc.c +++ b/emufs/fsc.c @@ -20,6 +20,7 @@ *---------------------------------------------------------------------------- * Creado: vie abr 9 16:17:50 ART 2004 * Autores: Nicolás Dimov + * Leandro Lucarella *---------------------------------------------------------------------------- * * $Id$ @@ -35,17 +36,19 @@ */ #include "fsc.h" -#include +#include "error.h" +#include "common.h" #include +#include -#define EMUFS_FSC_EXT ".fsc" - -typedef struct emufs_fsc_t { - int block; - int free_space; -} EMUFS_FSC; +/* Crea un archivo de Gaps o Espacio Libre en Bloque */ +int emufs_fsc_crear(EMUFS* efs) +{ + return emufs_crear_archivo_auxiliar(efs->nombre, EMUFS_FSC_EXT); +} -int emufs_fsc_agregar(EMUFS *emu, int num_bloque, int fs) +/* Agrega un registro al archivo de espacio libre en bloque. */ +int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID marker, EMUFS_FREE freespace) { FILE *f_fsc; EMUFS_FSC reg; @@ -54,18 +57,212 @@ int emufs_fsc_agregar(EMUFS *emu, int num_bloque, int fs) strcpy(name_f_fsc,emu->nombre); strcat(name_f_fsc, EMUFS_FSC_EXT); - /*cargo el registro*/ - reg.block = num_bloque; - reg.free_space = fs; - /*lo guardo en el archivo al final "a+"*/ - if ( (f_fsc = fopen(name_f_fsc,"a+"))==NULL ) return -1; + /* Lo guardo en el archivo al final "a+"*/ + if ( (f_fsc = fopen(name_f_fsc,"r+"))==NULL ) return -1; + /* lo busco.. si esta lo modifico y si no lo agrego */ + fseek(f_fsc,0,SEEK_SET); + while ( !feof(f_fsc) ){ + if ( fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + if ( reg.marker == marker ){ + fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); + reg.freespace = freespace; + fwrite(®,sizeof(EMUFS_FSC),1,f_fsc); + fclose(f_fsc); + return 0; + } + } + /* Cargo el registro */ + reg.marker = marker; + reg.freespace = freespace; fwrite(®,sizeof(EMUFS_FSC),1,f_fsc); fclose(f_fsc); return 0; } -/* busca el bloque y le resta fs de espacio libre */ -int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs) +/* Agrega un GAP en el archivo de Gaps para Filetype 2 */ +int emufs_fsc_agregar_gap(EMUFS *emu, EMUFS_OFFSET marker, EMUFS_FREE freespace) +{ + FILE *f_fsc; + EMUFS_FSC gap_aux,gap_before,gap_after,gap_new; + char name_f_fsc[255]; + EMUFS_REG_ID pos_gap_before = 0, pos_gap_after = 0; + unsigned long source,destination,limit,file_size,reg_count = 0,cant_moved = 0; + char found = 0; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + gap_before.marker = -1; + gap_after.marker = -1; + + /* Busco si hay un GAP por delante y/o por detras del que se esta por crear */ + /* para en dicho caso realizar un merge! */ + if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; + while ( !feof(f_fsc) ){ + if ( fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + + /* Chequeo si es un gap justo anterior al nuestro */ + if (gap_aux.marker+gap_aux.freespace == marker) { + gap_before.marker = gap_aux.marker; + gap_before.freespace = gap_aux.freespace; + pos_gap_before = reg_count; + } + + /* Chequeo si es un gap justo posterior al nuestro */ + if (gap_aux.marker == marker+freespace) { + gap_after.marker = gap_aux.marker; + gap_after.freespace = gap_aux.freespace; + pos_gap_after = reg_count; + } + reg_count += 1; + } + + /* Si no encontre gaps ni por delante ni por detras */ + if ((gap_before.marker == -1) && (gap_after.marker == -1)) { + /* Lo guardo ordenado donde deba ir */ + gap_new.marker = marker; + gap_new.freespace = freespace; + /* Busco el gap que sucede a este */ + fseek(f_fsc,0,SEEK_SET); + while (!feof(f_fsc)) { + if (fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + if (gap_aux.marker > gap_new.marker) { + found = 1; + break; + } + } + if (found == 1) { + /* Movemos todos los gaps desde el sucesor hasta el final, una pos adelante */ + limit = ftell(f_fsc) - sizeof(EMUFS_FSC); + fseek(f_fsc,0,SEEK_END); + reg_count = (ftell(f_fsc) - limit) / sizeof(EMUFS_FSC); + source = ftell(f_fsc) - sizeof(EMUFS_FSC); + + while (cant_moved < reg_count) + { + fseek(f_fsc,source,SEEK_SET); + fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc); + fwrite(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc); + source -= sizeof(EMUFS_FSC); + ++cant_moved; + } + /* Agrego el nuevo registro */ + fseek(f_fsc,limit,SEEK_SET); + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + } + else { + fseek(f_fsc,0,SEEK_END); + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + } + + fclose(f_fsc); + } + + /* Si encuentro un GAP Justo por delante pero no por detras */ + if ((gap_before.marker != -1) && (gap_after.marker == -1)) + { + /* Me posiciono en el registro que indica dicho gap y lo reescribo con */ + /* la suma de los espacios libres */ + fseek(f_fsc,sizeof(EMUFS_FSC)*pos_gap_before,0); + gap_new.marker = gap_before.marker; + gap_new.freespace = gap_before.freespace + freespace; + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + fclose(f_fsc); + } + + /* Si encuentro un GAP Justo por detras pero no por delante */ + if ((gap_before.marker == -1) && (gap_after.marker != -1)) + { + /* Me posiciono en el registro que indica dicho gap y lo reescribo con */ + /* los datos actualizados de offset y espacio */ + fseek(f_fsc,sizeof(EMUFS_FSC)*pos_gap_after,0); + gap_new.marker = gap_after.marker - freespace; + gap_new.freespace = gap_after.freespace + freespace; + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + fclose(f_fsc); + } + + /* Finalmente, si encuentro Justo por delante y por detras..*/ + if ((gap_before.marker != -1) && (gap_after.marker != -1)) + { + /* Guardo el nuevo GAP que posee los tres espacios sumados */ + if (pos_gap_before < pos_gap_after) { + fseek(f_fsc,sizeof(EMUFS_FSC)*pos_gap_before,0); + destination = sizeof(EMUFS_FSC)*pos_gap_after; + } + else { + fseek(f_fsc,sizeof(EMUFS_FSC)*pos_gap_after,0); + destination = sizeof(EMUFS_FSC)*pos_gap_before; + } + gap_new.marker = gap_before.marker; + gap_new.freespace = gap_before.freespace + freespace + gap_after.freespace; + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + + /* Preparo el escenario para la movida de registros */ + source = destination+sizeof(EMUFS_FSC); /* Salteo el gap que elimino! */ + fseek(f_fsc,0,SEEK_END); + file_size = ftell(f_fsc); + reg_count = (file_size - source) / sizeof(EMUFS_FSC); + + /* Comienzo a mover */ + while (cant_moved < reg_count) { + fseek(f_fsc,source,0); + fread(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + fseek(f_fsc,-sizeof(EMUFS_FSC)*2,SEEK_CUR); + fwrite(&gap_new,sizeof(EMUFS_FSC),1,f_fsc); + source += sizeof(EMUFS_FSC); + ++cant_moved; + } + fclose(f_fsc); + truncate(name_f_fsc, file_size - sizeof(EMUFS_FSC)); + } + + return 0; +} + +/* Elimina un registro GAP del archivo de espacios libres (gaps) */ +int emufs_fsc_remove_gap(EMUFS *emu, EMUFS_OFFSET marker) +{ + FILE *f_fsc; + EMUFS_FSC gap_aux; + char name_f_fsc[255]; + unsigned long source,destination,file_size,reg_count = 0,cant_moved = 0; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + /* Busco el Gap en el .fsc */ + if ((f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; + while ( !feof(f_fsc) ){ + if ( fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + if ( gap_aux.marker == marker ) break; + } + + /* Preparo el escenario para la movida de registros */ + fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); + destination = ftell(f_fsc); + source = destination+sizeof(EMUFS_FSC); /* Salteo el gap a eliminar! */ + fseek(f_fsc,0,SEEK_END); + file_size = ftell(f_fsc); + reg_count = (file_size - source) / sizeof(EMUFS_FSC); + + /* Comienzo a mover */ + while (cant_moved < reg_count) { + fseek(f_fsc,source,0); + fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc); + fseek(f_fsc,-sizeof(EMUFS_FSC)*2,SEEK_CUR); + fwrite(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc); + source += sizeof(EMUFS_FSC); + ++cant_moved; + } + fclose(f_fsc); + truncate(name_f_fsc, file_size - sizeof(EMUFS_FSC)); + + return 0; +} + +/* Objetivo: Actualiza un registro de espacio libre de acorde al FType */ +int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID marker, EMUFS_FREE freespace) { FILE *f_fsc; EMUFS_FSC reg; @@ -74,12 +271,12 @@ int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs) strcpy(name_f_fsc,emu->nombre); strcat(name_f_fsc, EMUFS_FSC_EXT); - /*busco el bloque que modifique*/ + /*busco el bloque o gap que modifique*/ if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; while ( !feof(f_fsc) ){ if ( fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; - if ( reg.block == num_bloque ){ - reg.free_space = fs; + if ( reg.marker == marker ){ + reg.freespace = freespace; fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); fwrite(®,sizeof(EMUFS_FSC),1,f_fsc); break; @@ -89,40 +286,141 @@ int emufs_fsc_actualizar(EMUFS *emu, int num_bloque, int fs) return 0; } -/* me devuelve el ID del bloque donde quepa un registro, y guarda en fs el espacio libre que queda en el bloque */ -int emufs_fsc_buscar_lugar(EMUFS *emu, unsigned long tam, int *fs) +/* Actualiza un registro de gap, en el archivo de Gaps en Disco */ +int emufs_fsc_actualizar_gap(EMUFS *emu, EMUFS_OFFSET marker, EMUFS_FREE freespace) +{ + FILE *f_fsc; + EMUFS_FSC gap_aux; + char name_f_fsc[255]; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + /*busco el bloque o gap que modifique*/ + if ( (f_fsc = fopen(name_f_fsc,"r+")) == NULL) return -1; + while ( !feof(f_fsc) ){ + if ( fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + if ( gap_aux.marker == marker ){ + gap_aux.marker = marker + gap_aux.freespace - freespace; + gap_aux.freespace = freespace; + fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); + fwrite(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc); + break; + } + } + fclose(f_fsc); + return 0; +} + +/* Me devuelve el ID del bloque u Offset del Gap donde quepa un registro, y guarda en n_freespace el espacio libre actualizado */ +EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE reg_size, EMUFS_FREE *freespace) { FILE *f_fsc; EMUFS_FSC reg; char name_f_fsc[255]; + char found = 0; strcpy(name_f_fsc,emu->nombre); strcat(name_f_fsc, EMUFS_FSC_EXT); - if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; + if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return EMUFS_NOT_FOUND; - /* Inicializo la estructura para evitar que si el archivo esta vacio - * el resultado sea correcto - */ - reg.block = -1; - *fs = emu->tam_bloque; - while( !feof(f_fsc) ){ + if ( emu->tam_reg > emu->tam_bloque-sizeof(EMUFS_REG_ID) ){ + fseek(f_fsc,0,SEEK_SET); + while(!feof(f_fsc)){ + if (fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; + if (reg.freespace == emu->tam_bloque) { + fclose(f_fsc); + *freespace = reg.freespace; + return reg.marker; + } + } + } + /* Inicializamos la estructura para devolver algun valor en concreto */ + /* en caso de que no se halle un espacio libre apropiado */ + while(!feof(f_fsc)){ if (fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; - if ( reg.free_space >= tam+sizeof(int)) + if (reg.freespace >= reg_size) { + found = 1; break; - else { - reg.block = -1; - *fs = emu->tam_bloque; } } + /* Si salio por error o por fin de archivo y no encontro space... */ + if (!found) { + reg.marker = EMUFS_NOT_FOUND; + *freespace = emu->tam_bloque; + } + else *freespace = reg.freespace; + fclose(f_fsc); - if (reg.block != -1) - *fs = reg.free_space; - return reg.block; + return reg.marker; } -int emufs_fsc_get_fs(EMUFS *emu, int num_bloque) +/** Busca n lugares consecutivos devolviendo el id del primer bloque. */ +EMUFS_BLOCK_ID emufs_fsc_buscar_n_lugares(EMUFS* efs, size_t n, + EMUFS_FREE size, EMUFS_FREE *freespace, int* err) +{ + FILE *f_fsc; + EMUFS_FSC reg; + char name_f_fsc[255]; + + /* chequeo que al menos se busque un lugar */ + if (!n) { + PERR("Se debe buscar al menos un lugar"); + *err = EMUFS_ERROR_WRONG_ARGUMENT; + return EMUFS_NOT_FOUND; + } + + /* abre archivo */ + strcpy(name_f_fsc, efs->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + if (!(f_fsc = fopen(name_f_fsc, "rb"))) { + PERR("No se puede abrir archivo"); + *err = EMUFS_ERROR_CANT_OPEN_FILE; + return EMUFS_NOT_FOUND; + } + + /* busca el espacio libre */ + while(!feof(f_fsc)) { + if ((fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1)) { + if (feof(f_fsc)) break; + PERR("No se puede leer el archivo"); + *err = EMUFS_ERROR_FILE_READ; + fclose(f_fsc); + return EMUFS_NOT_FOUND; + } + if (reg.freespace >= size) { + int found = 1; + EMUFS_BLOCK_ID first_id = reg.marker; + *freespace = reg.freespace; + while (--n) { + if (fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1) { + if (feof(f_fsc)) break; + PERR("No se puede leer el archivo"); + *err = EMUFS_ERROR_FILE_READ; + fclose(f_fsc); + return EMUFS_NOT_FOUND; + } + /* no hay otro lugar consecutivo */ + if (reg.freespace < size) { + found = 0; + break; + } + } + if (found) { + fclose(f_fsc); + return first_id; + } + } + } + /* no se encontró espacio libre */ + *freespace = efs->tam_bloque; + return EMUFS_NOT_FOUND; +} + +/* Devuelve el espacio libre de un Bloque o Gap dado */ +EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID marker) { FILE *f_fsc; EMUFS_FSC reg; @@ -131,14 +429,152 @@ int emufs_fsc_get_fs(EMUFS *emu, int num_bloque) strcpy(name_f_fsc,emu->nombre); strcat(name_f_fsc, EMUFS_FSC_EXT); + /* Busco el Bloque o Gap pedido y obtengo su espacio libre */ if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; - while ( !feof(f_fsc) ){ if ( fread(®,sizeof(EMUFS_FSC),1,f_fsc) != 1 ) continue; - if ( reg.block == num_bloque ) + if ( reg.marker == marker ) break; } fclose(f_fsc); - return reg.free_space; + return reg.freespace; +} + +EMUFS_FREE emufs_fsc_get_total_fs(EMUFS *emu) +{ + FILE *f_fsc; + EMUFS_FSC reg; + char name_f_fsc[255]; + EMUFS_FREE total; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; + total = 0; + while ( !feof(f_fsc) ){ + if ( fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1) continue; + if ( reg.freespace > 0 ) + total += reg.freespace; + } + fclose(f_fsc); + return total; +} + +int emufs_fsc_get_max_min_fs(EMUFS *emu, EMUFS_FREE *min, EMUFS_FREE *max) +{ + FILE *f_fsc; + EMUFS_FSC reg; + char name_f_fsc[255]; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; + + /* Si el file esta vacio, devuelvo valores nulos */ + fseek(f_fsc,0,SEEK_END); + if (ftell(f_fsc) == 0) { + *min = 0; + *max = 0; + return 0; + } + else + { + /* Busco Min y Max */ + *min = ULONG_MAX; + *max = 0; + fseek(f_fsc,0,SEEK_SET); + while ( !feof(f_fsc) ){ + if ( fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1) continue; + if ( reg.freespace < *min ) + *min = reg.freespace; + if ( reg.freespace > *max ) + *max = reg.freespace; + } + fclose(f_fsc); + return 0; + } +} + +EMUFS_FREE emufs_fsc_get_media_fs(EMUFS *emu) +{ + FILE *f_fsc; + EMUFS_FSC reg; + char name_f_fsc[255]; + EMUFS_FREE total_fs = 0; + EMUFS_REG_ID gap_count = 0; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; + + while ( !feof(f_fsc) ){ + if ( fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1) continue; + total_fs += reg.freespace; + ++gap_count; + } + + fclose(f_fsc); + + if (gap_count > 0) return total_fs/gap_count; + else return 0; +} + +EMUFS_BLOCK_ID emufs_fsc_get_cant_bloques_vacios(EMUFS *emu) +{ + FILE *f_fsc; + EMUFS_FSC reg; + char name_f_fsc[255]; + EMUFS_BLOCK_ID cant=0; + + strcpy(name_f_fsc,emu->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return -1; + while ( !feof(f_fsc) ){ + fread(®, sizeof(EMUFS_FSC), 1, f_fsc); + if ( reg.freespace == emu->tam_bloque ) + cant++; + } + + fclose(f_fsc); + return cant; +} + +int emufs_fsc_truncate(EMUFS* efs, EMUFS_BLOCK_ID blocks) +{ + char name_f_fsc[255]; + + strcpy(name_f_fsc, efs->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + return truncate(name_f_fsc, blocks * sizeof(EMUFS_FSC)); +} + +EMUFS_BLOCK_ID emufs_fsc_get_num_blocks(EMUFS* efs) +{ + FILE *f_fsc; + char name_f_fsc[255]; + EMUFS_BLOCK_ID cant = 0; + + strcpy(name_f_fsc, efs->nombre); + strcat(name_f_fsc, EMUFS_FSC_EXT); + + if (!(f_fsc = fopen(name_f_fsc, "ab"))) { + PERR("error al abrir archivo .fsc"); + return EMUFS_NOT_FOUND; + } + cant = ftell(f_fsc) / sizeof(EMUFS_FSC); + fclose(f_fsc); + return cant; +} + +long emufs_fsc_get_file_size(EMUFS* efs, int* err) +{ + char name[255]; + strcpy(name, efs->nombre); + strcat(name, EMUFS_FSC_EXT); + return emufs_common_get_file_size(name, err); }