Paso el fin de línea a formato Unix (perdon tenia que verlo para estudiar :P).

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

diff --git a/emufs/tipo3.c b/emufs/tipo3.c
index 9771588c974c834eb591ef35c1ac93e5f2f22af0..0ebccc50becb63d831c93d21522ce8b58c895300 100644 (file)
--- a/emufs/tipo3.c
+++ b/emufs/tipo3.c
@@ -44,7 +44,7 @@
 
 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
                                        void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
 
 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
                                        void *bloque, int num_bloque, EMUFS_FREE fs, int *err);

-
+static void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque);

 
 int emufs_tipo3_inicializar(EMUFS* efs)
 {
 
 int emufs_tipo3_inicializar(EMUFS* efs)
 {


@@ -64,7 +64,8 @@ int emufs_tipo3_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;

-       efs->tam_reg = 0;
+       efs->modificar_registro= emufs_tipo3_modificar_registro;
+       efs->obtener_claves_raw= emufs_tipo3_obtener_claves_raw;

        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 


@@ -86,7 +87,8 @@ int emufs_tipo5_inicializar(EMUFS* efs)
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;
        efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
        efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
        efs->compactar         = emufs_tipo3_compactar;

-       efs->tam_reg = 0;
+       efs->modificar_registro= emufs_tipo3_modificar_registro_plus;
+       efs->obtener_claves_raw= emufs_tipo3_obtener_claves_raw;

        return EMUFS_OK;
 }
 
        return EMUFS_OK;
 }
 


@@ -113,7 +115,6 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                block = dato.bloque;
                ID = dato.id;
                PERR("Use indice");
                block = dato.bloque;
                ID = dato.id;
                PERR("Use indice");

-               fprintf(stderr, "Datos leidos : id=%ld, bloque=%ld\n", ID, block);

        } else {
                /* Si no tengo claves, uso el campo entero para pasar un ID
                 * directamente.
        } else {
                /* Si no tengo claves, uso el campo entero para pasar un ID
                 * directamente.


@@ -121,6 +122,7 @@ void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
                PERR("Use directo");
                ID = clave.i_clave;
                block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
                PERR("Use directo");
                ID = clave.i_clave;
                block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/

+               if (*err == 1) *err = 0;

        }
        if ( block == EMUFS_NOT_FOUND ){
                PERR("No se encontro el bloque");
        }
        if ( block == EMUFS_NOT_FOUND ){
                PERR("No se encontro el bloque");


@@ -222,6 +224,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
        char* bloque = NULL;
        int cant_bloques, resto, i=0;
        
        char* bloque = NULL;
        int cant_bloques, resto, i=0;
        

+       PERR("TIPO3 GRABRAR REGISTRO");

        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        
        strcpy(name_f,emu->nombre);
        strcat(name_f,".dat");
        


@@ -242,7 +245,10 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
 
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == EMUFS_NOT_FOUND) {
 
        /*si no hay bloques con suficiente espacio creo un bloque nuevo */
        if (num_bloque == EMUFS_NOT_FOUND) {

-               if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
+               if ( (file = fopen(name_f,"a+"))==NULL ) {
+                       PERR("NO SE PUDO ABRIR ARCHIVO DE DATOS");
+                       return -1; /*ERROR*/
+               }

                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);
                /* El free esta al final de la funcion! */
                /*tengo que buscar un ID valido para el nuevo registro*/
                ID_aux = emufs_idx_get_new_id(emu, err);
                /* El free esta al final de la funcion! */


@@ -274,6 +280,7 @@ 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 ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
                        if (i == 0) {
                                /* Tengo que agregar el primer bloque en IDX */
                                if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){

+                                       PERR("FALLO AGREGAR A IDX");

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


@@ -289,6 +296,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                        if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
                                fclose(file);
                                free(bloque);
                        if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
                                fclose(file);
                                free(bloque);

+                               PERR("FALLO AGREGAR A IDX");

                                return -1;
                        }
                }
                                return -1;
                        }
                }


@@ -338,6 +346,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
                                        fclose(file);
                                        if (bloque) free(bloque);
                                if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
                                        fclose(file);
                                        if (bloque) free(bloque);

+                                       PERR("FALLO AGREGAR A IDX");

                                        return -1;
                                }
                        } else {        
                                        return -1;
                                }
                        } else {        


@@ -346,12 +355,14 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                                if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
                                        fclose(file);
                                        if (bloque) free(bloque);
                                if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
                                        fclose(file);
                                        if (bloque) free(bloque);

+                                       PERR("FALLO AGREGAR A FSC");

                                        return -1;
                                }
                        }
                        if ( i == 0 ){
                                if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
                                        if (bloque) free(bloque);
                                        return -1;
                                }
                        }
                        if ( i == 0 ){
                                if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
                                        if (bloque) free(bloque);

+                                       PERR("FALLO AGREGAR A IDX");

                                        return -1;
                                }
                                idx_data.id = ID_aux;
                                        return -1;
                                }
                                idx_data.id = ID_aux;


@@ -361,6 +372,7 @@ EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE t
                }
        }
        if (bloque) free(bloque);
                }
        }
        if (bloque) free(bloque);

+       PERR("GRABAR COMPLETO");

        return ID_aux;
 }
 
        return ID_aux;
 }
 


@@ -634,6 +646,7 @@ void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, c
 
 EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {
 
 EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
 {

+       INDICE_DATO idx_data;

        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_REG_ID header;
        CLAVE clave, menor_clave_bloque_nuevo;
        EMUFS_BLOCK_ID num_bloque; 
        EMUFS_REG_ID header;


@@ -659,6 +672,7 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
        0 = Sin problemas, retorno bloque donde insertar
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */
        0 = Sin problemas, retorno bloque donde insertar
        1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
        */

+       header = emufs_idx_get_new_id(emu, err);

        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        if (result == 1){
                PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");


@@ -672,7 +686,6 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        return -1;
                }
                memset(bloque, 0, emu->tam_bloque);
                        return -1;
                }
                memset(bloque, 0, emu->tam_bloque);

-               header = emufs_idx_get_new_id(emu, err);

                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                        free(bloque);
                if (*err) {
                        PERR("NO SE PUDO OBTENER UN ID");
                        free(bloque);


@@ -695,8 +708,14 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque);
                if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque);

-               /*agrego la clave al arbol*/
+               /*agrego la clave al arbol bplus*/

                emufs_b_plus_insertar(emu->indices, &query);
                emufs_b_plus_insertar(emu->indices, &query);

+               /*agrego el id a idx*/
+               emufs_idx_agregar(emu, header, query.num_bloque);
+               /*actualizo los restantes arboles */
+               idx_data.id = header;
+               idx_data.bloque = query.num_bloque;
+               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                free(bloque);
                return header;
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
                free(bloque);
                return header;
        } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/


@@ -716,6 +735,9 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        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*/

+                       idx_data.id = header;
+                       idx_data.bloque = query.num_bloque;
+                       emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                        free(bloque);
                        return header;
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                        free(bloque);
                        return header;
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */


@@ -733,10 +755,10 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                        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));
                        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));

-                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
+                       menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));                   

                        /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
                        /* 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 */
+                       if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, query.clave) ){
+                               PERR("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*/
                                /*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*/


@@ -747,9 +769,14 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                                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);
                                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 los ids de idx*/
+                               b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);

                                /*actualizo el arbol con la nueva clave*/
                                /*actualizo el arbol con la nueva clave*/

+                               idx_data.id = header;
+                               idx_data.bloque = query.num_bloque;

                                query.clave = clave;
                                query.clave = clave;

-                               emufs_b_plus_insertar(emu->indices, &query);
+                               emufs_b_plus_insertar(emu->indices, &query);                            
+                               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                                /*grabo el bloque original*/
                                emufs_tipo3_grabar_bloque(emu, bloque, num_bloque);
                        } else {
                                /*grabo el bloque original*/
                                emufs_tipo3_grabar_bloque(emu, bloque, num_bloque);
                        } else {


@@ -767,10 +794,15 @@ EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE
                                query.num_bloque = emufs_create_new_block(emu);
                                /*grabo el bloque nuevo*/
                                emufs_tipo3_grabar_bloque(emu, new_bloque, query.num_bloque);
                                query.num_bloque = emufs_create_new_block(emu);
                                /*grabo el bloque nuevo*/
                                emufs_tipo3_grabar_bloque(emu, new_bloque, query.num_bloque);

+                               /*actualizo los ids del bloque nuevo*/
+                               b_plus_actualizar_ids(emu, new_bloque, query.num_bloque);

                                /*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_REG_ID));
                                /*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_REG_ID));

+                               idx_data.id = header;
+                               idx_data.bloque = query.num_bloque;
+                               emufs_indice_agregar(emu->indices->sig, ptr, idx_data);

                                emufs_b_plus_insertar(emu->indices, &query);
                        }
                        if(*err != 0){
                                emufs_b_plus_insertar(emu->indices, &query);
                        }
                        if(*err != 0){


@@ -845,6 +877,7 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
        memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
        emufs_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
        clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));

+       emufs_idx_agregar(emu, header, num_bloque);

        free(new_bloque);
        return clave;
 }
        free(new_bloque);
        return clave;
 }


@@ -852,9 +885,11 @@ CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void
 int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
 {
        char *bloque, *aux;
 int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
 {
        char *bloque, *aux;

+       INDICE_DATO idx_data;

        INDEX_DAT query;
        int result, iter, cant_reg;
        EMUFS_REG_SIZE tam_reg = emu->tam_reg;
        INDEX_DAT query;
        int result, iter, cant_reg;
        EMUFS_REG_SIZE tam_reg = emu->tam_reg;

+       EMUFS_REG_ID id;

        CLAVE clave_ajena, ancla;
        int err = 0;
 
        CLAVE clave_ajena, ancla;
        int err = 0;
 


@@ -863,7 +898,6 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
        query.clave = clave;
        /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
        query.clave = clave;
        /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
        result = emufs_b_plus_get_bloque(emu->indices, &query, 0);

-       printf("bloque = %d\n", query.num_bloque);

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


@@ -888,14 +922,16 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
        while ( iter < emu->tam_bloque ){
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
        while ( iter < emu->tam_bloque ){
                clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
                if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){

-                       /*tenngo que borrar este registro*/
+                       /*tengo que borrar este registro*/
+                       /*leo el id*/
+                       memcpy(&id, aux, sizeof(EMUFS_REG_ID));

                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_REG_ID));
                        /*hay que reacomodar todo*/
                        /*me posiciono en el reg siguiente*/
                        iter += tam_reg+sizeof(EMUFS_REG_ID);
                        break;/*ya borre, corto aca*/
                        /*limpio el espacio que ocupaba*/
                        memset(aux, 0, tam_reg+sizeof(EMUFS_REG_ID));
                        /*hay que reacomodar todo*/
                        /*me posiciono en el reg siguiente*/
                        iter += tam_reg+sizeof(EMUFS_REG_ID);
                        break;/*ya borre, corto aca*/

-               }
+               }               

                iter += tam_reg+sizeof(EMUFS_REG_ID);
                aux += tam_reg+sizeof(EMUFS_REG_ID);
        }
                iter += tam_reg+sizeof(EMUFS_REG_ID);
                aux += tam_reg+sizeof(EMUFS_REG_ID);
        }


@@ -920,6 +956,11 @@ int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
                        emufs_b_plus_reemplazar_clave(emu->indices, ancla, query, 0);
                }
        }
                        emufs_b_plus_reemplazar_clave(emu->indices, ancla, query, 0);
                }
        }

+       emufs_idx_borrar(emu, id);
+       /* Elimino la entrada de los restantes arboles */                               
+       idx_data.id = id;
+       idx_data.bloque = query.num_bloque;
+       emufs_indice_borrar(emu->indices->sig, clave, idx_data);

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


@@ -983,3 +1024,62 @@ EMUFS_REG_ID emufs_tipo3_modificar_registro_plus(EMUFS *emu, CLAVE k, void *ptr
        emufs_tipo3_eliminar_ordenado(emu, k, dato);
        return emufs_tipo3_insertar_ordenado(emu, ptr, size, err);
 }
        emufs_tipo3_eliminar_ordenado(emu, k, dato);
        return emufs_tipo3_insertar_ordenado(emu, ptr, size, err);
 }

+
+B_PLUS_KEYBUCKET *emufs_tipo3_obtener_claves_raw(EMUFS *emu, int num_bloque)
+{
+       B_PLUS_KEYBUCKET *keys;
+       char *bloque, *aux;
+       int err = 0, cant_reg, i;
+       EMUFS_REG_SIZE tam_reg = emu->tam_reg;
+       
+       keys = (B_PLUS_KEYBUCKET*)malloc(sizeof(B_PLUS_KEYBUCKET));
+       if (keys == NULL){
+               PERR("NO SE PUDO CREAR EL BUCKET");
+               return NULL;
+       }
+       /*leo el bloque*/
+       bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err);
+       if ( bloque == NULL ){
+               PERR("NO SE PUDO LEER EL BLOQUE");
+               return NULL;
+       }
+       aux = bloque;
+       /*leo la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*ya se cuanto guardarle al vector*/
+       keys->claves = (CLAVE*)malloc(cant_reg*sizeof(CLAVE));
+       if (keys->claves == NULL){
+               PERR("NO SE PUDO CREAR EL ARRAY DE CLAVES");
+               free(keys);
+               return NULL;
+       }
+       keys->cant_keys = cant_reg;
+       keys->current_key = 0;
+       
+       for (i=0; i<cant_reg; i++){
+               keys->claves[i] = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_REG_ID));
+               bloque += tam_reg+sizeof(EMUFS_REG_ID);
+       }
+       free(aux);
+       return keys;
+}
+
+void b_plus_actualizar_ids(EMUFS *emu, void *bloque, int num_bloque)
+{
+       EMUFS_REG_ID id;
+       int cant_reg,i;
+       EMUFS_REG_SIZE tam_reg = emu->tam_reg;
+       char *aux;
+       /*leo la cantidad de registros*/
+       memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
+       /*reemplazo todos los ids*/
+       aux = bloque;
+       for(i=0; i<cant_reg; i++){
+               /*leo id a reemplazar*/
+               memcpy(&id, aux, sizeof(EMUFS_REG_ID));
+               /*reemplazo el id*/
+               emufs_idx_agregar(emu, id, num_bloque);
+               /*me muevo para la sig iteracion*/
+               aux += tam_reg+sizeof(EMUFS_REG_ID);
+       }
+}