Blah..renaming..

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

diff --git a/emufs/tipo1.c b/emufs/tipo1.c
index 98ddb6e7759d1e63f19114c0941d7124f1f5113f..e82e1b4dc957cc34cdf9500321b88d73131cbcdc 100644 (file)
--- a/emufs/tipo1.c
+++ b/emufs/tipo1.c
@@ -75,8 +75,8 @@ 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 insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err);
+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 ----------------------*/
 
 
 /*------------------ Funciones públicas ----------------------*/
 


@@ -796,14 +796,14 @@ 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)
 {

-       #ifdef ESTO_NO_ANDA_TODAVIA
-       CLAVE clave, clave_ajena;
+       CLAVE clave;

        EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); 
        EMUFS_TIPO1_REG_HEADER header;
        EMUFS_BLOCK_ID num_bloque = get_new_block_number(emu); 
        EMUFS_TIPO1_REG_HEADER header;

-       EMUFS_REG_SIZE tam_reg;
+       EMUFS_REG_SIZE tam_reg, move_size;

        INDEX_DAT query;
        INDEX_DAT query;

-       char *bloque, *aux, *new_bloque, *registro;
-       int cant_reg, i, j;
+       EMUFS_FREE fs;
+       char *bloque, *aux, *new_bloque;
+       int cant_reg, i, result, dif;

        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
        query.num_bloque = num_bloque;  
        
        /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
        query.num_bloque = num_bloque;  


@@ -814,21 +814,31 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
        /*debo insertar el reg en el bloque en forma ordenada*/
        /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
        /*debo insertar el reg en el bloque en forma ordenada*/
        /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
        /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/

-       if ( emu->indices->emufs_b_plus_get_bloque(ind, &query) == -1 ){
+       /* emufs_b_plus_get_bloque retorna asi
+       -1 = Nuevo bloque, retorno idem num_bloque que ingreso
+       0 = Sin problemas, retorno bloque donde insertar
+       1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
+       */
+       result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
+       if (result == 1){
+               PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
+               return -1;
+       }
+       if ( result == -1 ){            

                /*creo un bloque nuevo*/
                bloque = (char*) malloc(emu->tam_bloque);
                if (bloque == NULL){
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }
                /*creo un bloque nuevo*/
                bloque = (char*) malloc(emu->tam_bloque);
                if (bloque == NULL){
                        PERR("NO SE PUDO CREAR EL BLOQUE");
                        return -1;
                }

-               header.id = emufs_idx_get_new_id(efs, err);
+               header.id = emufs_idx_get_new_id(emu, err);

                header.size = size;
                cant_reg = 1;
                /*pongo la cabecera en el registro*/
                memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER)); 
                /*inserto el footer en el bloque*/
                memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
                header.size = size;
                cant_reg = 1;
                /*pongo la cabecera en el registro*/
                memcpy(bloque, &header, sizeof(EMUFS_TIPO1_REG_HEADER)); 
                /*inserto el footer en el bloque*/
                memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));

-               /*inserto el registro en el bloque*/
+               /*inserto el registro en el bloqude*/

                if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
                        memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size); 
                else {
                if ( size <= emu->tam_bloque-sizeof(EMUFS_TIPO1_REG_HEADER)-sizeof(int) )
                        memcpy(bloque+sizeof(EMUFS_TIPO1_REG_HEADER), ptr, size); 
                else {


@@ -839,7 +849,7 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                /*hago lugar en el archivo para grabar*/
                if ( num_bloque != create_new_block(emu) )      PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
                /*hago lugar en el archivo para grabar*/
                if ( num_bloque != create_new_block(emu) )      PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
                /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */

-               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query->num_bloque, EMUFS_NOT_FOUND, err);
+               emufs_tipo1_grabar_bloque_fsc(emu, bloque, query.num_bloque, EMUFS_NOT_FOUND, err);

                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);
                /*agrego la clave al arbol*/
                emufs_b_plus_insertar(emu->indices, &query);
                free(bloque);


@@ -850,40 +860,70 @@ int emufs_tipo1_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, in
                /*me fijo cuantos registros hay en el */
                memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
                /*me fijo si entra en nuevo reg en el bloque */
                /*me fijo cuantos registros hay en el */
                memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
                /*me fijo si entra en nuevo reg en el bloque */

+               fs = emu->tam_bloque;

                aux = bloque;
                for (i=0; i<cant_reg; i++){
                        memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;
                aux = bloque;
                for (i=0; i<cant_reg; i++){
                        memcpy(&tam_reg, aux+sizeof(EMUFS_REG_ID), sizeof(EMUFS_REG_SIZE));
                        aux += sizeof(EMUFS_TIPO1_REG_HEADER)+tam_reg;

-                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER);
+                       fs -= (tam_reg+sizeof(EMUFS_TIPO1_REG_HEADER));

                } /*aca deberia estar apuntando al final de los registros. espacio libre*/
                fs -= sizeof(int); /*footer*/
                } /*aca deberia estar apuntando al final de los registros. espacio libre*/
                fs -= sizeof(int); /*footer*/

-               if ( fs >= size ){ /* puedo meter el registro en este bloque*/  
-                       insertar_odenado_en_bloque(emu, ptr, size, bloque, query->num_bloque, err);
+               if ( fs >= size+sizeof(EMUFS_TIPO1_REG_HEADER) ){ /* puedo meter el registro en este bloque*/   
+                       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*/
                        return 0;
                /*aca va lo que saque*/
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                        new_bloque = (char*)malloc(emu->tam_bloque);
                        /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
                        return 0;
                /*aca va lo que saque*/
                } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
                        new_bloque = (char*)malloc(emu->tam_bloque);

-                       for(i=0; i<cant_reg/2; i++);
-                               
-       #endif
+                       move_size=0;
+                       for(i=0; i<cant_reg/2; i++){ /*copio mitad 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;
+                       }
+                       /*copio el resto del bloque al nuevo bloque*/
+                       memcpy(new_bloque, aux, emu->tam_bloque-move_size);
+                       /*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 = 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);
+                       free(new_bloque);
+                       free(bloque);
+                       return 0;
+               }
+       }
+       return 0;

 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
 }
 
 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/

-CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, int *err)
+CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)

 {
 {

-       /*#ifdef CAMBIAR*/

        char *aux, *new_bloque;
        int cant_reg, tam_reg, i, j;
        EMUFS_TIPO1_REG_HEADER header;
        char *aux, *new_bloque;
        int cant_reg, tam_reg, i, j;
        EMUFS_TIPO1_REG_HEADER header;

-       EMUFS_FREE fs;

        CLAVE clave, clave_ajena;
        
        CLAVE clave, clave_ajena;
        

+       /*saco la cant de registros del bloque*/

        memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
        memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));

+       /*obtengo la clave del nuevo registro*/

        clave = emufs_indice_generar_clave(emu->indices, ptr);
        clave = emufs_indice_generar_clave(emu->indices, ptr);

+       /*cargo el header*/

        header.id = emufs_idx_get_new_id(emu, err);
        header.size = size;
        header.id = emufs_idx_get_new_id(emu, err);
        header.size = size;

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

        new_bloque = (char*)malloc(emu->tam_bloque);
        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){
        new_bloque = (char*)malloc(emu->tam_bloque);
        aux = new_bloque;
        for (i=0; i<cant_reg+1; i++){


@@ -920,12 +960,10 @@ CLAVE insertar_odenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, voi
                break; /*corto el for porque ya inserte todos*/
                }
        }
                break; /*corto el for porque ya inserte todos*/
                }
        }

-       free(bloque);/*no lo uso mas*/

        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/
        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));
        free(new_bloque);
        return clave;
        /*grabo el bloque en el archivo*/
        new_bloque = aux; /*apunto al principio del bloque*/
        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));
        free(new_bloque);
        return clave;

-       /*#endif CAMBIAR*/

 }
 }