From 409b3712f9aafe1d8a9c2da8c5284ac0afebcfb0 Mon Sep 17 00:00:00 2001 From: Alan Kennedy Date: Mon, 12 Apr 2004 03:48:18 +0000 Subject: [PATCH] Normalizacion de nomenclatura en FSC.c y TIPO2.c, ergo cambios requeridos en emufs.c que lo utiliza directo en ver archivo. Also fix a tipo1.c y tipo3.c dado el cambio del tipo EMUFS_TYPE a EMUFS_Tipo, para que compilen. --- emufs/emufs.c | 2 +- emufs/fsc.c | 161 ++++++++++++++++++++++++-------------------------- emufs/fsc.h | 6 +- emufs/tipo1.c | 2 +- emufs/tipo2.c | 112 ++++++++++++++++++----------------- emufs/tipo3.c | 6 +- 6 files changed, 141 insertions(+), 148 deletions(-) diff --git a/emufs/emufs.c b/emufs/emufs.c index 9956bf6..148ccc4 100644 --- a/emufs/emufs.c +++ b/emufs/emufs.c @@ -263,7 +263,7 @@ int ver_archivo_FS(EMUFS *emu) } 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); } diff --git a/emufs/fsc.c b/emufs/fsc.c index e71d13d..164050e 100644 --- a/emufs/fsc.c +++ b/emufs/fsc.c @@ -46,7 +46,7 @@ int emufs_fsc_crear(EMUFS* efs) } /* Agrega un registro al archivo de espacio libre en bloque. */ -int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespace) +int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID marker, EMUFS_FREE freespace) { FILE *f_fsc; EMUFS_FSC reg; @@ -56,8 +56,8 @@ int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespac strcat(name_f_fsc, EMUFS_FSC_EXT); /* Cargo el registro */ - reg.n_marker = n_marker; - reg.n_freespace = n_freespace; + reg.marker = marker; + reg.freespace = freespace; /* Lo guardo en el archivo al final "a+"*/ if ( (f_fsc = fopen(name_f_fsc,"a+"))==NULL ) return -1; @@ -67,19 +67,19 @@ int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_freespac } /* Agrega un GAP en el archivo de Gaps para Filetype 2 */ -int emufs_fsc_agregar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_freespace) +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 n_gap_before = 0, n_gap_after = 0; - unsigned long n_source,n_destination,n_filesize,n_reg_count = 0,n_moved = 0; + EMUFS_REG_ID pos_gap_before = 0, pos_gap_after = 0; + 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); - gap_before.n_marker = -1; - gap_after.n_marker = -1; + 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! */ @@ -88,108 +88,100 @@ int emufs_fsc_agregar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_freesp if ( fread(&gap_aux,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue; /* Chequeo si es un gap justo anterior al nuestro */ - if (gap_aux.n_marker+gap_aux.n_freespace == n_marker) { - gap_before.n_marker = gap_aux.n_marker; - gap_before.n_freespace = gap_aux.n_freespace; - n_gap_before = n_reg_count; + 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.n_marker == n_marker+n_freespace) { - gap_after.n_marker = gap_aux.n_marker; - gap_after.n_freespace = gap_aux.n_freespace; - n_gap_after = n_reg_count; + if (gap_aux.marker == marker+freespace) { + gap_after.marker = gap_aux.marker; + gap_after.freespace = gap_aux.freespace; + pos_gap_after = reg_count; } - n_reg_count += 1; + reg_count += 1; } /* Si no encontre gaps ni por delante ni por detras */ - if ((gap_before.n_marker == -1) && (gap_after.n_marker == -1)) { + if ((gap_before.marker == -1) && (gap_after.marker == -1)) { /* Lo guardo en el archivo al final */ - gap_new.n_marker = n_marker; - gap_new.n_freespace = n_freespace; + gap_new.marker = marker; + gap_new.freespace = freespace; 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.n_marker != -1) && (gap_after.n_marker == -1)) + if ((gap_before.marker != -1) && (gap_after.marker == -1)) { - printf("fsc.c >> Found GAP justo por Delante pero no por Detras!!\n"); - printf("fsc.c >> Gap found is reg number %lu in .fsc file\n",n_gap_before); /* 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)*n_gap_before,0); - gap_new.n_marker = gap_before.n_marker; - gap_new.n_freespace = gap_before.n_freespace + n_freespace; + 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.n_marker == -1) && (gap_after.n_marker != -1)) - { - printf("fsc.c >> Found GAP justo por Detras pero no por Delante!!\n"); - printf("fsc.c >> Gap found is reg number %lu in .fsc file\n",n_gap_after); + 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)*n_gap_after,0); - gap_new.n_marker = gap_after.n_marker - n_freespace; - gap_new.n_freespace = gap_after.n_freespace + n_freespace; + 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.n_marker != -1) && (gap_after.n_marker != -1)) - { - printf("fsc.c >> Found GAP justo por Delante y por Detras!!\n"); - printf("fsc.c >> Pre Gap found is reg number %lu in .fsc file\n",n_gap_before); - printf("fsc.c >> Post Gap found is reg number %lu in .fsc file\n",n_gap_after); + if ((gap_before.marker != -1) && (gap_after.marker != -1)) + { /* Guardo el nuevo GAP que posee los tres espacios sumados */ - if (n_gap_before < n_gap_after) { - fseek(f_fsc,sizeof(EMUFS_FSC)*n_gap_before,0); - n_destination = sizeof(EMUFS_FSC)*n_gap_after; + 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)*n_gap_after,0); - n_destination = sizeof(EMUFS_FSC)*n_gap_before; + fseek(f_fsc,sizeof(EMUFS_FSC)*pos_gap_after,0); + destination = sizeof(EMUFS_FSC)*pos_gap_before; } - gap_new.n_marker = gap_before.n_marker; - gap_new.n_freespace = gap_before.n_freespace + n_freespace + gap_after.n_freespace; + 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 */ - n_source = n_destination+sizeof(EMUFS_FSC); /* Salteo el gap que elimino! */ + source = destination+sizeof(EMUFS_FSC); /* Salteo el gap que elimino! */ fseek(f_fsc,0,SEEK_END); - n_filesize = ftell(f_fsc); - n_reg_count = (n_filesize - n_source) / sizeof(EMUFS_FSC); - printf("Destination: %lu Source: %lu Cant Regs a Mover: %lu\n",n_destination,n_source,n_reg_count); - + file_size = ftell(f_fsc); + reg_count = (file_size - source) / sizeof(EMUFS_FSC); + /* Comienzo a mover */ - while (n_moved < n_reg_count) { - fseek(f_fsc,n_source,0); + 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); - n_source += sizeof(EMUFS_FSC); - ++n_moved; + source += sizeof(EMUFS_FSC); + ++cant_moved; } fclose(f_fsc); - truncate(name_f_fsc, n_filesize - sizeof(EMUFS_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 n_marker) +int emufs_fsc_remove_gap(EMUFS *emu, EMUFS_OFFSET marker) { FILE *f_fsc; EMUFS_FSC gap_aux; char name_f_fsc[255]; - unsigned long n_source,n_destination,n_filesize,n_reg_count = 0,n_moved = 0; + 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); @@ -198,35 +190,34 @@ int emufs_fsc_remove_gap(EMUFS *emu, EMUFS_OFFSET n_marker) 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.n_marker == n_marker ) break; + if ( gap_aux.marker == marker ) break; } /* Preparo el escenario para la movida de registros */ fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); - n_destination = ftell(f_fsc); - n_source = n_destination+sizeof(EMUFS_FSC); /* Salteo el gap a eliminar! */ + destination = ftell(f_fsc); + source = destination+sizeof(EMUFS_FSC); /* Salteo el gap a eliminar! */ fseek(f_fsc,0,SEEK_END); - n_filesize = ftell(f_fsc); - n_reg_count = (n_filesize - n_source) / sizeof(EMUFS_FSC); - printf("Destination: %lu Source: %lu Cant Regs a Mover: %lu\n",n_destination,n_source,n_reg_count); + file_size = ftell(f_fsc); + reg_count = (file_size - source) / sizeof(EMUFS_FSC); /* Comienzo a mover */ - while (n_moved < n_reg_count) { - fseek(f_fsc,n_source,0); + 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); - n_source += sizeof(EMUFS_FSC); - ++n_moved; + source += sizeof(EMUFS_FSC); + ++cant_moved; } fclose(f_fsc); - truncate(name_f_fsc, n_filesize - sizeof(EMUFS_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 n_marker, EMUFS_FREE n_freespace) +int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID marker, EMUFS_FREE freespace) { FILE *f_fsc; EMUFS_FSC reg; @@ -239,8 +230,8 @@ int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_frees 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.n_marker == n_marker ){ - reg.n_freespace = n_freespace; + if ( reg.marker == marker ){ + reg.freespace = freespace; fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR); fwrite(®,sizeof(EMUFS_FSC),1,f_fsc); break; @@ -251,7 +242,7 @@ int emufs_fsc_actualizar(EMUFS *emu, EMUFS_BLOCK_ID n_marker, EMUFS_FREE n_frees } /* Actualiza un registro de gap, en el archivo de Gaps en Disco */ -int emufs_fsc_actualizar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_freespace) +int emufs_fsc_actualizar_gap(EMUFS *emu, EMUFS_OFFSET marker, EMUFS_FREE freespace) { FILE *f_fsc; EMUFS_FSC gap_aux; @@ -264,9 +255,9 @@ int emufs_fsc_actualizar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_fre 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.n_marker == n_marker ){ - gap_aux.n_marker = n_marker + gap_aux.n_freespace - n_freespace; - gap_aux.n_freespace = n_freespace; + 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; @@ -277,7 +268,7 @@ int emufs_fsc_actualizar_gap(EMUFS *emu, EMUFS_OFFSET n_marker, EMUFS_FREE n_fre } /* 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 n_regsize, EMUFS_FREE *n_freespace) +EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE reg_size, EMUFS_FREE *freespace) { FILE *f_fsc; EMUFS_FSC reg; @@ -293,7 +284,7 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE n_regsize, EMUFS_FR /* 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.n_freespace >= n_regsize) { + if (reg.freespace >= reg_size) { found = 1; break; } @@ -301,17 +292,17 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE n_regsize, EMUFS_FR /* Si salio por error o por fin de archivo y no encontro space... */ if (!found) { - reg.n_marker = EMUFS_NOT_FOUND; - *n_freespace = emu->tam_bloque; + reg.marker = EMUFS_NOT_FOUND; + *freespace = emu->tam_bloque; } - else *n_freespace = reg.n_freespace; + else *freespace = reg.freespace; fclose(f_fsc); - return reg.n_marker; + return reg.marker; } /* Devuelve el espacio libre de un Bloque o Gap dado */ -EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID n_marker) +EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID marker) { FILE *f_fsc; EMUFS_FSC reg; @@ -324,12 +315,12 @@ EMUFS_FREE emufs_fsc_get_fs(EMUFS *emu, EMUFS_BLOCK_ID n_marker) 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.n_marker == n_marker ) + if ( reg.marker == marker ) break; } fclose(f_fsc); - return reg.n_freespace; + return reg.freespace; } EMUFS_FREE emufs_fsc_get_total_fs(EMUFS *emu) @@ -346,7 +337,7 @@ EMUFS_FREE emufs_fsc_get_total_fs(EMUFS *emu) total = 0; while ( !feof(f_fsc) ){ if ( fread(®, sizeof(EMUFS_FSC), 1, f_fsc) != 1) continue; - total += reg.n_freespace; + total += reg.freespace; } fclose(f_fsc); return total; diff --git a/emufs/fsc.h b/emufs/fsc.h index 230876c..ec932df 100644 --- a/emufs/fsc.h +++ b/emufs/fsc.h @@ -43,14 +43,14 @@ #define EMUFS_FSC_EXT ".fsc" typedef struct emufs_fsc_t { - unsigned long int n_marker; - unsigned long int n_freespace; + unsigned long int marker; + unsigned long int freespace; } EMUFS_FSC; int emufs_fsc_crear(EMUFS*); int emufs_fsc_agregar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE); int emufs_fsc_agregar_gap(EMUFS *, EMUFS_OFFSET, EMUFS_FREE); -int emufs_fsc_remove_gap(EMUFS *emu, EMUFS_OFFSET n_reg_offset); +int emufs_fsc_remove_gap(EMUFS *emu, EMUFS_OFFSET); int emufs_fsc_actualizar_gap(EMUFS *, EMUFS_OFFSET, EMUFS_FREE); int emufs_fsc_actualizar(EMUFS *, EMUFS_BLOCK_ID, EMUFS_FREE); EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *, EMUFS_FREE, EMUFS_FREE *); diff --git a/emufs/tipo1.c b/emufs/tipo1.c index ebbb10a..042fdb4 100644 --- a/emufs/tipo1.c +++ b/emufs/tipo1.c @@ -329,7 +329,7 @@ int emufs_tipo1_block_jump(EMUFS* efs, FILE* fp, EMUFS_BLOCK_ID block_count) size_t emufs_tipo1_header_size(void) { - return sizeof(EMUFS_TYPE) + /* Cabecera de tipo de archivo */ + return sizeof(EMUFS_Tipo) + /* Cabecera de tipo de archivo */ sizeof(EMUFS_BLOCK_SIZE); /* Cabecera de tamaño del bloque */ } diff --git a/emufs/tipo2.c b/emufs/tipo2.c index 5b0ebdf..bf59bf0 100644 --- a/emufs/tipo2.c +++ b/emufs/tipo2.c @@ -42,15 +42,18 @@ int emufs_tipo2_inicializar(EMUFS* efs) efs->grabar_registro = emufs_tipo2_grabar_registro; efs->borrar_registro = emufs_tipo2_borrar_registro; efs->leer_registro = emufs_tipo2_leer_registro; + + return 0; } /**********************************************************************/ -/* EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, */ -/* EMUFS_REG_SIZE n_RegSize) */ -/* Objetivo: Grabar un registro en un archivo del Tipo 2. */ +/* void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, */ +/* EMUFS_REG_SIZE* reg_size, int *err) */ +/* Objetivo: Lee un registro de un archivo del Tipo 2. */ /* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */ -/* void *ptr // Puntero al buffer (registro) a guardar */ -/* EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion */ +/* EMUFS_REG_ID reg_id // Id del registro a cargar */ +/* EMUFS_REG_SIZE *reg_size // Size del reg en cuestion */ +/* int *err // Indicador de errores */ /**********************************************************************/ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, EMUFS_REG_SIZE* reg_size, int *err) @@ -95,12 +98,12 @@ void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID reg_id, /* void *ptr // Puntero al buffer (registro) a guardar */ /* EMUFS_REG_SIZE n_RegSize // Size del reg en cuestion */ /**********************************************************************/ -EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n_RegSize, int* err) +EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE reg_size, int* err) { - EMUFS_REG_ID n_IdReg; - EMUFS_FREE n_FreeSpace; - EMUFS_OFFSET n_WrtOffset,n_RegOffset; - unsigned long int n_FisicSize; + EMUFS_REG_ID id_reg; + EMUFS_FREE freespace; + EMUFS_OFFSET wrt_offset,reg_offset; + unsigned long int fisic_size; FILE *f_data; char name_f[255]; @@ -112,52 +115,52 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n /* Obtengo un offset en donde iniciar la escritura de mi registro */ /* de manera segura (habra espacio suficiente) */ - n_FisicSize = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+n_RegSize; - n_WrtOffset = emufs_fsc_buscar_lugar(efs,n_FisicSize,&n_FreeSpace); - printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace); + fisic_size = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+reg_size; + wrt_offset = emufs_fsc_buscar_lugar(efs,fisic_size,&freespace); + /*printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);*/ /* Si no encontre un gap, entonces escribo el registro al final */ - if (n_WrtOffset == -1) { + if (wrt_offset == -1) { /* Obtengo un ID libre para el registro y luego grabo a disco */ - n_IdReg = emufs_idx_get_new_id(efs, err); + id_reg = emufs_idx_get_new_id(efs, err); fseek(f_data, 0, SEEK_END); - n_RegOffset = ftell(f_data); + reg_offset = ftell(f_data); /* Escribo [RegId]|[RegSize]|[RegData] */ - fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data); - fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data); - fwrite(ptr,n_RegSize,1,f_data); + fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data); + fwrite(®_size,sizeof(EMUFS_REG_SIZE),1,f_data); + fwrite(ptr,reg_size,1,f_data); /* Bye */ - printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset); + /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/ fclose(f_data); } else { /* Obtengo un ID libre para el registro y luego grabo en disco */ - n_IdReg = emufs_idx_get_new_id(efs, err); - n_RegOffset = n_WrtOffset; - fseek(f_data,n_RegOffset,0); + id_reg = emufs_idx_get_new_id(efs, err); + reg_offset = wrt_offset; + fseek(f_data,reg_offset,0); /* Escribo [RegId]|[RegSize]|[RegData] */ - fwrite(&n_IdReg,sizeof(EMUFS_REG_ID),1,f_data); - fwrite(&n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data); - fwrite(ptr,n_RegSize,1,f_data); + fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data); + fwrite(®_size,sizeof(EMUFS_REG_SIZE),1,f_data); + fwrite(ptr,reg_size,1,f_data); /* Bye */ - printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset); + /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/ fclose(f_data); /* Actualizo el espacio libre en el GAP donde puse el registro */ - if ((n_FreeSpace-n_FisicSize) == 0) emufs_fsc_remove_gap(efs,n_RegOffset); - else emufs_fsc_actualizar_gap(efs,n_RegOffset,n_FreeSpace-n_FisicSize); + if ((freespace-fisic_size) == 0) emufs_fsc_remove_gap(efs,reg_offset); + else emufs_fsc_actualizar_gap(efs,reg_offset,freespace-fisic_size); } /* Finalmente, actualizamos el indice de registros (offsets) */ - emufs_idx_agregar(efs,n_IdReg,n_RegOffset); + emufs_idx_agregar(efs,id_reg,reg_offset); - return n_IdReg; + return id_reg; } /**********************************************************************/ @@ -167,30 +170,30 @@ EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE n /* Parametros: EMUFS *efs // Struct con handlers + info del openfile. */ /* EMUFS_REG_ID n_IdReg // Id del registro a eliminar. */ /**********************************************************************/ -int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg) +int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID id_reg) { - EMUFS_OFFSET n_RegOffset,n_RegSize; + EMUFS_OFFSET reg_offset,reg_size; /* Obtenemos el offset donde arranca el registro */ - if ((n_RegOffset = emufs_idx_buscar_registro(efs,n_IdReg)) != -1) - printf("tipo2.c >> Searching Reg %lu...Found at offset: %lu\n",n_IdReg,n_RegOffset); - else - return -1; + if ((reg_offset = emufs_idx_buscar_registro(efs,id_reg)) == EMUFS_NOT_FOUND) { + /* TODO Manejo de errores */ + PERR("Registro no encontrado"); + return EMUFS_NOT_FOUND; + } /* Obtenemos el Size del Registro en cuestion y hacemos un dummyfill*/ - emufs_tipo2_get_regsize(efs,n_RegOffset,&n_RegSize); - printf ("tipo2.c >> About to delete Reg %lu of Size: %lu\n",n_IdReg,n_RegSize); - emufs_tipo2_dummyfill(efs,n_RegOffset,n_RegSize); - + emufs_tipo2_get_regsize(efs,reg_offset,®_size); + emufs_tipo2_dummyfill(efs,reg_offset,reg_size); + /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */ /* otro GAP por delante y/o por detras en caso de hallarlo. */ - emufs_fsc_agregar_gap(efs,n_RegOffset,n_RegSize+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)); + emufs_fsc_agregar_gap(efs,reg_offset,reg_size+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)); /* Agrego el ID que se ha liberado al archivo de ID's Libres */ - emufs_did_agregar(efs,n_IdReg); + emufs_did_agregar(efs,id_reg); /* Borramos el registro del indice de posiciones relativas */ - emufs_idx_borrar(efs,n_IdReg); + emufs_idx_borrar(efs,id_reg); return(0); } @@ -203,7 +206,7 @@ int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID n_IdReg) /* EMUFS_OFFSET n_RegPos // Offset al inicio del registro */ /* EMUFS_REG_SIZE *n_RegSize // Size to lookup and return */ /**********************************************************************/ -int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n_RegSize) +int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *reg_size) { FILE *f_data; char name_f[255]; @@ -213,8 +216,8 @@ int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n strcat(name_f,".dat"); if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */ - fseek(f_data,n_RegPos+sizeof(EMUFS_REG_ID),SEEK_SET); - fread(n_RegSize,sizeof(EMUFS_REG_SIZE),1,f_data); + fseek(f_data,reg_pos+sizeof(EMUFS_REG_ID),SEEK_SET); + fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data); fclose(f_data); return (0); @@ -229,13 +232,13 @@ int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE *n /* EMUFS_OFFSET n_RegPos // Offset al inicio del registro */ /* EMUFS_REG_SIZE *n_Amount // Size to lookup and return */ /**********************************************************************/ -int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Amount) +int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount) { FILE *f_data; char name_f[255]; char *dummyfill; char *ptr_cur; - unsigned long n_FillSize,n_count; + unsigned long fill_size,byte_count; /* Armamos el filename del archivo de datos */ strcpy(name_f,efs->nombre); @@ -244,15 +247,14 @@ int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET n_RegPos, EMUFS_REG_SIZE n_Am if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */ /* Preparo el garbage y se lo tiro encima */ - n_FillSize = n_Amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE); - dummyfill = (char*)malloc(n_FillSize); + fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE); + dummyfill = (char*)malloc(fill_size); ptr_cur = dummyfill; - for (n_count = 0; n_count < n_FillSize; ++n_count) memcpy(ptr_cur+n_count,"#",1); - fseek(f_data,n_RegPos,SEEK_SET); - fwrite(dummyfill,n_FillSize,1,f_data); + for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,"#",1); + fseek(f_data,reg_pos,SEEK_SET); + fwrite(dummyfill,fill_size,1,f_data); fclose(f_data); - /* printf("Dummy Fill: %s\n",dummyfill); */ /*Uncomment to check */ free(dummyfill); return (0); } diff --git a/emufs/tipo3.c b/emufs/tipo3.c index afe97d4..0e657e9 100644 --- a/emufs/tipo3.c +++ b/emufs/tipo3.c @@ -99,7 +99,7 @@ void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_REG_ID ID, int* err) *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */ return NULL; /* FIXME ERROR */ } - fseek(file,sizeof(EMUFS_TYPE)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET); + fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET); /*FIXME: verificar que no se pase de fin de archivo*/ fseek(file,ID*emu->tam_bloque,SEEK_CUR); block = (char*) malloc(emu->tam_bloque); @@ -156,7 +156,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t /*tengo que buscar la cantidad de bloques que existen*/ /*me paro al principio salteando el encabezado del archivo*/ fseek(file, 0, SEEK_END); /* Me paro al final */ - cant = (ftell(file)-(sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque; + cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque; cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */ fclose(file); num_bloque = cant; @@ -212,7 +212,7 @@ int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num) if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/ /* Salto el header del archivo */ - fseek(file, sizeof(EMUFS_TYPE)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET); + fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET); fseek(file, num*emu->tam_bloque, SEEK_CUR); fwrite(ptr, emu->tam_bloque, 1, file); -- 2.43.0