hice unos pequeños cambios en fsc e idx pero no creo que afecte en nada a los otros...

-en fsc el agregar primero se fija si el bloque existe y si no existe lo agrega al final
-en idx... ya no me acuerdo que cambie.. puede ser que haya quedado igual..

diff --git a/emufs/fsc.c b/emufs/fsc.c
index a3aad0e6cf0058b31343e3040dabc74518ff0d06..044ef3352d57e7a6a044da9a4a27165bf24b68a1 100644 (file)
--- a/emufs/fsc.c
+++ b/emufs/fsc.c
@@ -55,12 +55,23 @@ int emufs_fsc_agregar(EMUFS *emu, EMUFS_BLOCK_ID marker, EMUFS_FREE freespace)
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        
        strcpy(name_f_fsc,emu->nombre);
        strcat(name_f_fsc, EMUFS_FSC_EXT);
        

+       /* 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(&reg,sizeof(EMUFS_FSC),1,f_fsc) != 1) continue;
+               if ( reg.marker == marker ){
+                       fseek(f_fsc,-sizeof(EMUFS_FSC),SEEK_CUR);
+                       reg.freespace = freespace;
+                       fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
+                       fclose(f_fsc);
+                       return 0;
+               }
+       }

        /* Cargo el registro */
        reg.marker = marker;
        reg.freespace = freespace;
        /* Cargo el registro */
        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;

        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
        fclose(f_fsc);
        return 0;
        fwrite(&reg,sizeof(EMUFS_FSC),1,f_fsc);
        fclose(f_fsc);
        return 0;


@@ -280,6 +291,17 @@ EMUFS_BLOCK_ID emufs_fsc_buscar_lugar(EMUFS *emu, EMUFS_FREE reg_size, EMUFS_FRE
 
        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return EMUFS_NOT_FOUND;
 
 
        if ( (f_fsc = fopen(name_f_fsc,"r"))==NULL ) return EMUFS_NOT_FOUND;
 

+       if ( emu->tam_reg > emu->tam_bloque-sizeof(EMUFS_REG_ID) ){
+               fseek(f_fsc,0,SEEK_SET);
+               while(!feof(f_fsc)){
+                       if (fread(&reg,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)){
        /* Inicializamos la estructura para devolver algun valor en concreto */
        /* en caso de que no se halle un espacio libre apropiado */
        while(!feof(f_fsc)){

diff --git a/emufs/idx.c b/emufs/idx.c
index 50f3d1cd35c157944a7b3d23272fb658e188b4de..701ba2597cdf0be3fd123c0dcaec0414045c7a18 100644 (file)
--- a/emufs/idx.c
+++ b/emufs/idx.c
@@ -131,7 +131,6 @@ EMUFS_BLOCK_ID emufs_idx_buscar_registro(EMUFS *emu, EMUFS_REG_ID reg_id)
        return EMUFS_NOT_FOUND;
 }
 
        return EMUFS_NOT_FOUND;
 }
 

-/* agrega un registro al final del archivo */

 int emufs_idx_agregar(EMUFS *emu, EMUFS_REG_ID id_reg, EMUFS_BLOCK_ID location)
 {
        FILE *f_idx;
 int emufs_idx_agregar(EMUFS *emu, EMUFS_REG_ID id_reg, EMUFS_BLOCK_ID location)
 {
        FILE *f_idx;


@@ -141,7 +140,7 @@ int emufs_idx_agregar(EMUFS *emu, EMUFS_REG_ID id_reg, EMUFS_BLOCK_ID location)
        strcpy(name_f_idx,emu->nombre);
        strcat(name_f_idx, EMUFS_IDX_EXT);
 
        strcpy(name_f_idx,emu->nombre);
        strcat(name_f_idx, EMUFS_IDX_EXT);
 

-       if ( (f_idx = fopen(name_f_idx,"r+"))==NULL ) return -1;
+       if ( (f_idx = fopen(name_f_idx,"a+"))==NULL ) return -1;

 
        fseek(f_idx, sizeof(EMUFS_IDX)*id_reg, SEEK_SET); 
        reg.id_reg = id_reg;
 
        fseek(f_idx, sizeof(EMUFS_IDX)*id_reg, SEEK_SET); 
        reg.id_reg = id_reg;


@@ -242,13 +241,13 @@ int emufs_idx_existe_id(EMUFS *emu, int ID)
        
        if (fseek(f_idx, sizeof(EMUFS_IDX)*ID, SEEK_SET) == 0) {
                fread(&reg, sizeof(EMUFS_IDX), 1, f_idx);
        
        if (fseek(f_idx, sizeof(EMUFS_IDX)*ID, SEEK_SET) == 0) {
                fread(&reg, sizeof(EMUFS_IDX), 1, f_idx);

-               if (reg.location == EMUFS_NOT_FOUND) {
+               if (reg.location != EMUFS_NOT_FOUND) {

                        fclose(f_idx);
                        fclose(f_idx);

-                       return -1;
+                       return 0;

                }
        }
        fclose(f_idx);
                }
        }
        fclose(f_idx);

-       return 0;/*no existe el id*/
+       return -1;/*no existe el id*/

 }
 
 int emufs_idx_actualizar(EMUFS *emu, int ID, EMUFS_BLOCK_ID bloque)
 }
 
 int emufs_idx_actualizar(EMUFS *emu, int ID, EMUFS_BLOCK_ID bloque)


@@ -265,7 +264,7 @@ int emufs_idx_actualizar(EMUFS *emu, int ID, EMUFS_BLOCK_ID bloque)
                return -1;
        }
        printf("actualice el id = %d\n",ID);
                return -1;
        }
        printf("actualice el id = %d\n",ID);

-       /*fseek(f_idx,0,SEEK_SET);*/
+       fseek(f_idx,0,SEEK_SET);

        fseek(f_idx,ID*sizeof(EMUFS_IDX),SEEK_SET);
        fread(&reg,sizeof(EMUFS_IDX),1,f_idx);
        reg.location = bloque;
        fseek(f_idx,ID*sizeof(EMUFS_IDX),SEEK_SET);
        fread(&reg,sizeof(EMUFS_IDX),1,f_idx);
        reg.location = bloque;

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 596e2a2eb6909e9a16a0873933ef17b9c00c3b6c..224c09665878699ddc50191c2b374f2b00a2a8d2 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -48,7 +48,7 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
        EMUFS_BLOCK_SIZE iterador = 0;
        int cant_bloques = 0, resto, i, copiado=0;
        
        EMUFS_BLOCK_SIZE iterador = 0;
        int cant_bloques = 0, resto, i, copiado=0;
        

-       cant_bloques = emu->tam_reg / emu->tam_bloque + 1;
+       cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;

        
        /*si existe, lo busco en el archivo de bloques*/
        block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
        
        /*si existe, lo busco en el archivo de bloques*/
        block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/


@@ -90,7 +90,6 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
                                        break;
                                }
                                *reg_size = emu->tam_reg;
                                        break;
                                }
                                *reg_size = emu->tam_reg;

-                               fprintf(stderr, "ACA VALE %d\n", emu->tam_reg);

                        }
                        iterador += emu->tam_reg;
                }
                        }
                        iterador += emu->tam_reg;
                }


@@ -150,10 +149,11 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        

-       cant_bloques = emu->tam_reg / emu->tam_bloque + 1;
+       cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;

        resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
        resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
        /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
        num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);

+       printf("encontre lugar en %d\n", num_bloque);

        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == -1) {
                if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/


@@ -188,54 +188,89 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
 
                        if (i == 0) {
                                /* Tengo que agregar el primer bloque en IDX */
 
                        if (i == 0) {
                                /* Tengo que agregar el primer bloque en IDX */

-                               if ( emufs_idx_existe_id(emu,ID_aux) != 0){ /* deberia ser == 0 pero no funca*/
-                                       emufs_idx_actualizar(emu, ID_aux, num_bloque);
-                               } else {
-                                       if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
-                                               free(bloque);
-                                               return -1;
+                               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                       free(bloque);
+                                       return -1;

                                        }
                                        }

-                               }

                        }
                        }

+

                        /* grabo el nuevo registro en el archivo de espacios libres */
                        if ( emu->tam_bloque > emu->tam_reg ) resto = emu->tam_reg;
                        /* grabo el nuevo registro en el archivo de espacios libres */
                        if ( emu->tam_bloque > emu->tam_reg ) resto = emu->tam_reg;

-                       if ( emufs_fsc_agregar(emu, num_bloque, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
+                       if ( emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {

                                fclose(file);
                                free(bloque);
                                return -1;
                        }
                                fclose(file);
                                free(bloque);
                                return -1;
                        }

+                               

                }
                fclose(file);
        } else {
                }
                fclose(file);
        } else {

-               /*cargo el bloque en "bloque"*/
-               if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, err))) {
-                       /* TODO Manejo de errores */
-                       PERR("no se pudo leer el bloque");
-                       return -1;
-               }
-               /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
-               /*insertar el registro en el bloque*/
-               /*tengo que buscar un ID valido para el nuevo registro*/
-               ID_aux = emufs_idx_get_new_id(emu, err);
-               /*grabo el id en el bloque*/
-               memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
-               /*grabo el registro en el bloque*/
-               memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
-               if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) != 0) {
-                       PERR("error al grabar bloque");
-                       return -1; /* se produjo un error */    
-               }
-               /*actualizo el archivo de espacios libres*/
-               if ( emufs_fsc_actualizar(emu, num_bloque, fs - emu->tam_reg - sizeof(EMUFS_REG_ID)) != 0 ){
-                       free(bloque);
-                       return -1;
-               }
-               /*actualizo el archivo de bloques y registros*/
-               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
-                       free(bloque);
-                       return -1;
+               for (i=0; i<cant_bloques; i++){
+                       /*cargo el bloque en "bloque"*/
+                       if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
+                               /* TODO Manejo de errores */
+                               PERR("no se pudo leer el bloque");
+                               return -1;
+                       }
+                       /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
+                       /*insertar el registro en el bloque*/
+                       /*tengo que buscar un ID valido para el nuevo registro*/
+                       ID_aux = emufs_idx_get_new_id(emu, err);
+                       /*grabo el id en el bloque*/
+                       /*veo el espacio libre que queda*/ 
+                       fs = emufs_fsc_get_fs(emu, num_bloque+i);
+                       printf("el espacio libre del bloque %d es: %d\n", num_bloque+i, fs);
+                       if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
+                               memcpy(bloque+sizeof(EMUFS_REG_ID),&ID_aux,sizeof(EMUFS_REG_ID));
+                       else
+                               memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
+                       /*grabo el registro en el bloque*/
+                       if ( cant_bloques == 1 ){
+                               memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
+                       } else {
+                               if ( cant_bloques-1 == i )
+                                       resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
+                               memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
+                       }                               
+                       
+                       /*grabo el bloque en el archivo*/
+                       if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
+                               PERR("error al grabar bloque");
+                               return -1; /* se produjo un error */    
+                       }
+                       
+                       /*actualizo el archivo de espacios libres*/
+                       if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) > emu->tam_reg ){
+                               resto = emu->tam_reg;
+                               if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
+                                       fclose(file);
+                                       if (bloque != NULL) free(bloque);
+                                       return -1;
+                               }
+                               /*agrego al idx*/
+                               if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                               if (bloque != NULL) free(bloque);
+                                               return -1;
+                                       }
+                       } else {        
+                               if ( cant_bloques-1 == i )
+                                       resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
+                               fs = emufs_fsc_get_fs(emu,num_bloque+i);
+                               if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
+                                       fclose(file);
+                                       if (bloque != NULL) free(bloque);
+                                       return -1;
+                               }
+                               /*actualizo el archivo de bloques y registros*/
+                               if (i == 0) {
+                                       /* Tengo que agregar el primer bloque en IDX */
+                                       if( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
+                                               if (bloque != NULL) free(bloque);
+                                               return -1;
+                                       }
+                               }
+                       }                               

                }
                }

-

        }
        free(bloque);
        return ID_aux;
        }
        free(bloque);
        return ID_aux;


@@ -269,7 +304,7 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
        EMUFS_REG_ID ID_aux;
        EMUFS_FREE fs;
        char *bloque;
        EMUFS_REG_ID ID_aux;
        EMUFS_FREE fs;
        char *bloque;

-       int err = 0;
+       int err = 0, i;

 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 
        num_bloque = emufs_idx_buscar_registro(emu, ID);
        if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {


@@ -309,7 +344,8 @@ int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 
        /*actualizo archivo .fsc*/
        if ( emu->tam_bloque < emu->tam_reg ) {
 
        /*actualizo archivo .fsc*/
        if ( emu->tam_bloque < emu->tam_reg ) {

-               if ( emufs_fsc_actualizar(emu, num_bloque, emu->tam_bloque) != 0 ) return -1;
+               for (i=0; i<emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1; i++)
+                       if ( emufs_fsc_actualizar(emu, num_bloque+i, emu->tam_bloque) != 0 ) return -1;

        } else { 
                fs = emufs_fsc_get_fs(emu, num_bloque);
                if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
        } else { 
                fs = emufs_fsc_get_fs(emu, num_bloque);
                if ( emufs_fsc_actualizar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;

diff --git a/emufs/tipo3_main.c b/emufs/tipo3_main.c
index 8db07e1b8ce1b0592e7f00eb048c323845067493..602609a28fd0ef15240dc972807a6e68f0eccd73 100644 (file)
--- a/emufs/tipo3_main.c
+++ b/emufs/tipo3_main.c
@@ -58,6 +58,7 @@ int main(int argc, char *argv[])
                printf("Modo de uso : %s tam_bloque\n", argv[0]);
                return 1;
        }
                printf("Modo de uso : %s tam_bloque\n", argv[0]);
                return 1;
        }

+       

        strcpy(a, "1234567890");
        strcpy(c, "REGISTRO NUMERO 2. ESTE REGISTRO ES MUCHO MAS LARGO QUE EL UNO");
        strcpy(d, "ABCDEFGHIJKL");
        strcpy(a, "1234567890");
        strcpy(c, "REGISTRO NUMERO 2. ESTE REGISTRO ES MUCHO MAS LARGO QUE EL UNO");
        strcpy(d, "ABCDEFGHIJKL");


@@ -68,7 +69,8 @@ int main(int argc, char *argv[])
        strcpy(i, "me argrego despues de borrar a un registro");        
        
        fp = emufs_crear("articulos", T3, atoi(argv[1]), 100);
        strcpy(i, "me argrego despues de borrar a un registro");        
        
        fp = emufs_crear("articulos", T3, atoi(argv[1]), 100);

-
+       printf("cant de bloques = %d\n", fp->tam_reg/(fp->tam_bloque-sizeof(EMUFS_REG_ID)) +1);
+       printf("GRABANDO REGISTROS....\n");

        v[0] = fp->grabar_registro(fp, a, 100, &err);
        v[1] = fp->grabar_registro(fp, c, 100, &err);
        v[2] = fp->grabar_registro(fp, d, 100, &err);
        v[0] = fp->grabar_registro(fp, a, 100, &err);
        v[1] = fp->grabar_registro(fp, c, 100, &err);
        v[2] = fp->grabar_registro(fp, d, 100, &err);


@@ -77,18 +79,22 @@ int main(int argc, char *argv[])
        v[5] = fp->grabar_registro(fp, g, 100, &err);
        v[6] = fp->grabar_registro(fp, h, 100, &err);
        v[7] = fp->grabar_registro(fp, i, 100, &err);
        v[5] = fp->grabar_registro(fp, g, 100, &err);
        v[6] = fp->grabar_registro(fp, h, 100, &err);
        v[7] = fp->grabar_registro(fp, i, 100, &err);

+       for (j=0; j<8; j++)     
+               printf("Grabado : %d\n", v[j]);

        
        

+       printf("RECUPERANDO REGISTROS....\n");

        for (j=0; j<8; j++){    
                b_ptr = fp->leer_registro(fp, v[j], &reg_size, &err);
                printf("Recuperado : %s\n", b_ptr);
        }
        
        for (j=0; j<8; j++){    
                b_ptr = fp->leer_registro(fp, v[j], &reg_size, &err);
                printf("Recuperado : %s\n", b_ptr);
        }
        

+       printf("BORRANDO REGISTROS....\n");

        for (j=0; j<8; j++){    
                fp->borrar_registro(fp, v[j]);
                printf("borrado : %d\n", v[j]);
        }
        for (j=0; j<8; j++){    
                fp->borrar_registro(fp, v[j]);
                printf("borrado : %d\n", v[j]);
        }

-       ver_archivo_FS(fp);

        
        

+       printf("GRABANDO REGISTROS....\n");

        v[0] = fp->grabar_registro(fp, a, 100, &err);
        v[1] = fp->grabar_registro(fp, c, 100, &err);
        v[2] = fp->grabar_registro(fp, d, 100, &err);
        v[0] = fp->grabar_registro(fp, a, 100, &err);
        v[1] = fp->grabar_registro(fp, c, 100, &err);
        v[2] = fp->grabar_registro(fp, d, 100, &err);