tree view

[z.facultad/75.06/emufs.git] / emufs / tipo1.c

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 0e8f7dc69aced4f60f306216141a8a16eb50dddb..60ee65b247ef39b1151f77c76b34376913158a64 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -75,7 +75,7 @@ static void* emufs_tipo1_leer_bloque(EMUFS*, EMUFS_BLOCK_ID, int*);
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 
 static EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS*, void*,
                EMUFS_BLOCK_ID, EMUFS_FREE, int*);
 

-CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, 
+static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, 

                void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
 
 /*------------------ Funciones públicas ----------------------*/
                void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
 
 /*------------------ Funciones públicas ----------------------*/


@@ -369,7 +369,7 @@ EMUFS_REG_ID emufs_tipo1_grabar_registro(EMUFS* efs, void* reg,
        return header.id;
 }
 
        return header.id;
 }
 

-int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
+int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k, INDICE_DATO dato1)

 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */
 {
        char* block; /* bloque leido (en donde está el registro a leer) */
        EMUFS_BLOCK_ID block_id; /* id del bloque en donde esta el registro a leer */


@@ -399,6 +399,7 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
                return err;
        }
 
                return err;
        }
 

+       emufs_indice_borrar(efs->indices, k, dato1);

        /* Busco secuencialmente en el bloque el registro a leer */
        offset = 0;
        do {
        /* Busco secuencialmente en el bloque el registro a leer */
        offset = 0;
        do {


@@ -461,10 +462,7 @@ int emufs_tipo1_borrar_registro(EMUFS* efs, CLAVE k)
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */
                                /* si es necesario desplazar */
                                if (offset < offset_reg_end) {
                                        /* muevo la porción de bloque a izquierda */

-                                       /* XXX Este memcpy() puede copiar regiones de memoria que
-                                        * se superponen, si copia de principio a fin y byte a byte
-                                        * no debería haber problema */
-                                       memcpy(block + offset, block + offset_reg_end,
+                                       memmove(block + offset, block + offset_reg_end,

                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */
                                        memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,
                                                efs->tam_bloque - offset_reg_end);
                                        /* rellena el espacio libre con ceros para la GUI */
                                        memset(block + efs->tam_bloque - offset_reg_end - orig_fs + offset,


@@ -632,7 +630,7 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
                PERR("Error al obtener tamaño del archivo.");
                return EMUFS_NOT_FOUND;
        }
                PERR("Error al obtener tamaño del archivo.");
                return EMUFS_NOT_FOUND;
        }

-
+       

        /* abre archivo */
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");
        /* abre archivo */
        strcpy(name_f,efs->nombre);
        strcat(name_f,".dat");


@@ -698,9 +696,9 @@ EMUFS_BLOCK_ID emufs_tipo1_grabar_bloque_fsc(EMUFS *efs, void *block,
 }
 
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,
 }
 
 EMUFS_REG_ID emufs_tipo1_modificar_registro(EMUFS* efs, CLAVE k,

-               void *data, EMUFS_REG_SIZE size, int* err)
+               void *data, EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)

 {
 {

-       emufs_tipo1_borrar_registro(efs, k);
+       emufs_tipo1_borrar_registro(efs, k, dato);

        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 
        return emufs_tipo1_grabar_registro(efs, data, size, err);
 }
 


@@ -749,20 +747,18 @@ void emufs_tipo1_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
 
 int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {
 
 int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {

-       CLAVE clave;
+       CLAVE clave, menor_clave_bloque_nuevo;

        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_REG_SIZE tam_reg, move_size;
        INDEX_DAT query;
        EMUFS_FREE fs;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_REG_SIZE tam_reg, move_size;
        INDEX_DAT query;
        EMUFS_FREE fs;

-       char *bloque, *aux, *new_bloque;
+       char *bloque = 0, *aux, *new_bloque = 0;

        int cant_reg, i, result, dif;
        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
        int cant_reg, i, result, dif;
        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/

-       PERR("LEO EL NUMERO DE BLOQUE SIGUIENTE");

        num_bloque = emufs_get_new_block_number(emu);   
        query.num_bloque = num_bloque;
        num_bloque = emufs_get_new_block_number(emu);   
        query.num_bloque = num_bloque;

-       printf("BLOQUE NUMBER : %d\n", num_bloque);

        /*saco la clave del stream*/
        query.clave = emufs_indice_generar_clave(emu->indices, ptr);
        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
        /*saco la clave del stream*/
        query.clave = emufs_indice_generar_clave(emu->indices, ptr);
        /*mando a buscar en el arbol el bloque correspondiente a esa clave*/


@@ -776,7 +772,6 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);

-       printf("tengo que guardar en bloque: %d\n", query.num_bloque);

        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
                return -1;
        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
                return -1;


@@ -788,6 +783,7 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }

+               memset(bloque, 0, emu->tam_bloque);

                header.id = emufs_idx_get_new_id(emu, err);
                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                header.id = emufs_idx_get_new_id(emu, err);
                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");


@@ -834,40 +830,77 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                        PERR("GRABO ORDENADO");                 
                        grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
                        PERR("GRABO ORDENADO");                 
                        grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/

+                       free(bloque);

                        return 0;
                        return 0;

-               /*aca va lo que saque*/

                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */

+                       PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");

                        new_bloque = (char*)malloc(emu->tam_bloque);
                        new_bloque = (char*)malloc(emu->tam_bloque);

+                       memset(new_bloque,0,emu->tam_bloque);

                        move_size=0;
                        move_size=0;

-                       for(i=0; i<cant_reg/2; i++){ /*copio mitad aca y mitad en el nuevo*/
+                       aux = bloque;
+                       for(i=0; i<cant_reg/2; i++){ /*copio mitad-1 aca y mitad en el nuevo*/

                                /*avanzo*/
                                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                                aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
                                move_size += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
                                /*avanzo*/
                                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                                aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
                                move_size += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;

-                       }
-                       /*copio el resto del bloque al nuevo bloque*/
-                       memcpy(new_bloque, aux, emu->tam_bloque-move_size);
+                       }/*apunto al reg mitad_mas_uno para copiar todo a otro bloque*/
+                       /*copio el resto del bloque al nuevo bloque*/      /*footer ¿?*/
+                       memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));

                        /*borro lo que sobra en el bloque original, guardando el footer*/
                        memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
                        /*borro lo que sobra en el bloque original, guardando el footer*/
                        memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));

-                       /*actualizo la cant de registros (footer)*/
-                       memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
-                       /*grabo el bloque original*/
-                       emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
-                       /*actualizo el footer del nuevo bloque*/
-                       dif = cant_reg - i; /*por las dudas*/
-                       memcpy(new_bloque+emu->tam_bloque, &dif, sizeof(int));
-                       /*genero un nuevo espacio para un bloque en el archivo y lo cargo en query
-                         la clave ya estaba en query desde antes*/
-                       query.num_bloque = emufs_create_new_block(emu);
-                       /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
-                       clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
-                       /*actualizo el arbol con la nueva clave*/
-                       emufs_b_plus_insertar(emu->indices, &query);
+                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+                       /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
+                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, clave) ){
+                               /* GRABO EN EL BLOQUE NUEVO */
+                               /*actualizo la cant de registros del bloque original (footer)*/
+                               memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
+                               /*actualizo el footer del nuevo bloque*/
+                               dif = cant_reg - i; /*por las dudas*/
+                               memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
+                               /*genero un nuevo espacio para un bloque en el archivo y lo cargo en queryla clave ya estaba en query desde antes*/
+                               num_bloque = query.num_bloque;
+                               query.num_bloque = emufs_create_new_block(emu);
+                               /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
+                               clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
+                               /*actualizo el arbol con la nueva clave*/
+                               query.clave = clave;
+                               emufs_b_plus_insertar(emu->indices, &query);
+                               /*grabo el bloque original*/
+                               emufs_tipo1_grabar_bloque_fsc(emu, bloque, num_bloque, EMUFS_NOT_FOUND, err);
+                       } else {
+                               PERR("GRABO EN BLOQUE VIEJO");
+                               /* GRABO EN EL BLOQUE VIEJO */
+                               /*actualizo la cant de registros del bloque original (footer)*/
+                               memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
+                               /*actualizo el footer del nuevo bloque*/
+                               dif = cant_reg - i; /*por las dudas*/
+                               /*meto el footer en el reg */
+                               memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
+                               /*guardo el num de bloque original */
+                               num_bloque = query.num_bloque;
+                               /* pido un bloque nuevo para guardar */
+                               query.num_bloque = emufs_create_new_block(emu);
+                               /*grabo el bloque nuevo*/
+                               emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, query.num_bloque, EMUFS_NOT_FOUND, err);
+                               /*grabo el registro en el bloque original*/
+                               grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
+                               /*actualizo el arbol con la menor clave del bloque nuevo*/
+                               query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
+                               emufs_b_plus_insertar(emu->indices, &query);
+                       }
+                       if(*err != 0){
+                               PERR("NO SE PUDO GRABAR ORDENADO");
+                               free(new_bloque);
+                               free(bloque);
+                               return -1;
+                       }

                        free(new_bloque);
                        free(bloque);
                        return 0;
                }
        }
                        free(new_bloque);
                        free(bloque);
                        return 0;
                }
        }

+       if (new_bloque) free(new_bloque);
+       if (bloque) free(bloque);

        return 0;
 }
 
        return 0;
 }
 


@@ -886,8 +919,8 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
        /*cargo el header*/
        header.id = emufs_idx_get_new_id(emu, err);
        header.size = size;
        /*cargo el header*/
        header.id = emufs_idx_get_new_id(emu, err);
        header.size = size;

-       cant_reg++; /*voy a poner un reg mas*/

        new_bloque = (char*)malloc(emu->tam_bloque);
        new_bloque = (char*)malloc(emu->tam_bloque);

+       memset(new_bloque, 0, emu->tam_bloque);

        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){
                bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/
        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){
                bloque += sizeof(EMUFS_TIPO1_REG_HEADER); /*salteo el encabezado del registro*/


@@ -925,6 +958,7 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
        }
        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/
        }
        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/

+       cant_reg++; /*voy a poner un reg mas*/

        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));
        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo1_grabar_bloque_fsc(emu, new_bloque, num_bloque, EMUFS_NOT_FOUND, err);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_TIPO1_REG_HEADER));


@@ -936,9 +970,11 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
 {
        char *bloque, *aux;
        INDEX_DAT query;
 {
        char *bloque, *aux;
        INDEX_DAT query;

-       int result, iter, cant_reg;
+       int result, iter, cant_reg, leidos;

        EMUFS_REG_SIZE tam_reg;
        CLAVE clave_ajena;
        EMUFS_REG_SIZE tam_reg;
        CLAVE clave_ajena;

+       
+       

        /*cargo el query para buscar*/
        query.num_bloque = 0;
        query.clave = clave;
        /*cargo el query para buscar*/
        query.num_bloque = 0;
        query.clave = clave;


@@ -969,11 +1005,12 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
                /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
                /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
        }
                /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
                /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
        }

-       while ( iter < emu->tam_bloque ){
+       leidos = 0;
+       while ( iter < emu->tam_bloque /*&& leidos < cant_reg*/){

                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
                memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){

-                       /*tenngo que borrar este registro*/
+                       /*tengo que borrar este registro*/

                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /*hay que reacomodar todo*/
                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));
                        /*hay que reacomodar todo*/


@@ -981,20 +1018,75 @@ int emufs_tipo1_eliminar_ordenado(EMUFS *emu, CLAVE clave, int *err)
                        iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                        break;/*ya borre, corto aca*/
                }
                        iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                        break;/*ya borre, corto aca*/
                }

+               leidos++;

                iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
                iter += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);

-               aux += iter;
+               aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);

        }
        }

-       

        /*reacomodo el bloque */
        /*reacomodo el bloque */

-       memcpy(bloque+iter-tam_reg-sizeof(EMUFS_TIPO1_REG_HEADER), aux+iter, emu->tam_bloque-iter-sizeof(int)); 
+       memcpy(aux, aux+tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER), emu->tam_bloque-iter-sizeof(int)); 

        /*le vuelvo a copiar la cantidad de registros*/
        cant_reg--;
        memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        /*grabo el bloque en el archivo*/
        if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err) == EMUFS_NOT_FOUND ){
                PERR("NO SE PUDO GRABAR EL BLOQUE");
        /*le vuelvo a copiar la cantidad de registros*/
        cant_reg--;
        memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        /*grabo el bloque en el archivo*/
        if ( emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err) == EMUFS_NOT_FOUND ){
                PERR("NO SE PUDO GRABAR EL BLOQUE");

+               free(bloque);

                return -1;
        }
        free(bloque);
        return 0;
 }
                return -1;
        }
        free(bloque);
        return 0;
 }

+
+void *emufs_tipo1_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *size, int *err)
+{
+       CLAVE clave_ajena;
+       char *reg; 
+       char *bloque, *aux;
+       INDEX_DAT query;
+       int result, cant_reg, i;
+       EMUFS_REG_SIZE tam_reg;
+       
+       /*cargo el query*/
+       query.clave = clave;
+       query.num_bloque = 0;
+       /*hago la consulta*/
+       
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       
+       if (result == -1){
+               PERR("NO EXISTE EL BLOQUE");
+               return NULL;
+       }
+       if (result == 1){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL");
+               return NULL;
+       }
+       /*leo el bloque*/
+       bloque = emufs_tipo1_leer_bloque(emu, query.num_bloque, err);
+       /*busco el registro en el bloque*/
+       /*copio la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       aux = bloque;
+       for (i=0; i<cant_reg; i++){
+               /*copio el tamanio del registro*/
+               memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
+               /*leo la clave*/
+               clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_TIPO1_REG_HEADER));
+               if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
+                       reg = (char*)malloc(tam_reg);
+                       if (reg == NULL){
+                               PERR("NO SE PUDO CARGAR EL REGISTRO");
+                               *err = -1;
+                               free(bloque);
+                               return -1;
+                       }
+                       /*copio el registro*/
+                       memcpy(reg, aux+sizeof(EMUFS_TIPO1_REG_HEADER), tam_reg);
+                       *size = tam_reg;
+                       break; /*ya lo encontre, corto el for*/
+               }
+               aux += tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER); /*paso al proximo*/
+       }
+       free(bloque);
+       return reg;
+}