]> git.llucax.com Git - z.facultad/75.06/emufs.git/blob - emufs/tipo3.c
New test, borrado de B+ parece andar un 10, me falta agitar la raiz de un nivel 2...
[z.facultad/75.06/emufs.git] / emufs / tipo3.c
1 /* vim: set noexpandtab tabstop=4 shiftwidth=4:
2  *----------------------------------------------------------------------------
3  *                                  emufs
4  *----------------------------------------------------------------------------
5  * This file is part of emufs.
6  *
7  * emufs is free software; you can redistribute it and/or modify it under the
8  * terms of the GNU General Public License as published by the Free Software
9  * Foundation; either version 2 of the License, or (at your option) any later
10  * version.
11  *
12  * emufs is distributed in the hope that it will be useful, but WITHOUT ANY
13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
15  * details.
16  *
17  * You should have received a copy of the GNU General Public License along
18  * with emufs; if not, write to the Free Software Foundation, Inc., 59 Temple
19  * Place, Suite 330, Boston, MA  02111-1307  USA
20  *----------------------------------------------------------------------------
21  * Creado:  mié mar 31 17:26:46 ART 2004
22  * Autores: Nicolás Dimov <sagardua@uolsinectis.com.ar>
23  *----------------------------------------------------------------------------
24  *
25  * $Id$
26  *
27  */
28
29 /** \file
30  *
31  * Archivo con bloques y registros de longitud parametrizada.
32  * 
33  * Implementación del archivo con bloques y registros de longitud
34  * parametrizada.
35  *
36  */
37
38 #include "tipo3.h"
39 #include "error.h"
40 #include "common.h"
41 #include <unistd.h>
42 #include <stdio.h>
43 #include <string.h>
44
45 static CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size,
46                                         void *bloque, int num_bloque, EMUFS_FREE fs, int *err);
47
48
49 int emufs_tipo3_inicializar(EMUFS* efs)
50 {
51         /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
52          * (una relación 1/2 entre datos e info de control ya es lo suficientemente
53          * mala */
54         if (efs->tam_bloque < (sizeof(EMUFS_REG_ID) * 2)) {
55                 PERR("bloque demasiado chico");
56                 return EMUFS_ERROR_BLOCK_TOO_SMALL;
57         }
58         /* Asigna punteros a funciones. */
59         efs->leer_bloque       = emufs_tipo3_leer_bloque;
60         efs->leer_bloque_raw   = emufs_tipo3_leer_bloque_raw;
61         efs->grabar_registro   = emufs_tipo3_grabar_registro;
62         efs->borrar_registro   = emufs_tipo3_borrar_registro;
63         efs->leer_registro     = emufs_tipo3_leer_registro;
64         efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
65         efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
66         efs->compactar         = emufs_tipo3_compactar;
67         efs->tam_reg = 0;
68         return EMUFS_OK;
69 }
70
71 int emufs_tipo5_inicializar(EMUFS* efs)
72 {
73         /* como mínimo el tamaño de bloque debe ser 2 veces el tamaño de la cabecera
74          * (una relación 1/2 entre datos e info de control ya es lo suficientemente
75          * mala */
76         if (efs->tam_bloque < (sizeof(EMUFS_REG_ID) * 2)) {
77                 PERR("bloque demasiado chico");
78                 return EMUFS_ERROR_BLOCK_TOO_SMALL;
79         }
80         /* Asigna punteros a funciones. */
81         efs->leer_bloque       = emufs_tipo3_leer_bloque;
82         efs->leer_bloque_raw   = emufs_tipo3_leer_bloque_raw;
83         efs->grabar_registro   = emufs_tipo3_insertar_ordenado;
84         efs->borrar_registro   = emufs_tipo3_eliminar_ordenado;
85         efs->leer_registro     = emufs_tipo3_leer_registro_plus;
86         efs->leer_registro_raw = emufs_tipo3_leer_registro_raw;
87         efs->leer_estadisticas = emufs_tipo3_leer_estadisticas;
88         efs->compactar         = emufs_tipo3_compactar;
89         efs->tam_reg = 0;
90         return EMUFS_OK;
91 }
92
93 /** Leo un registro del archivo, devuelve NULL si no lo encuentra.**/
94 void* emufs_tipo3_leer_registro(EMUFS *emu, CLAVE clave,
95                 EMUFS_REG_SIZE* reg_size, int* err)
96 {
97         INDICE_DATO dato;
98         char* bloque;
99         char* registro; /* registro a leer */
100         EMUFS_BLOCK_ID block;
101         EMUFS_REG_ID ID_aux, ID;
102         EMUFS_BLOCK_SIZE iterador = 0;
103         int cant_bloques = 0, resto, i, copiado=0;
104
105         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
106         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque ) 
107                 cant_bloques = 1;
108         
109         /*si existe, lo busco en el archivo de bloques*/
110         if ((emu->indices != NULL) && (*err != 1)) {
111                 /* TODO : Verificar donde esta el indice primario */
112                 dato = emu->indices->existe_entrada(emu->indices, clave);
113                 block = dato.bloque;
114                 ID = dato.id;
115                 PERR("Use indice");
116         } else {
117                 /* Si no tengo claves, uso el campo entero para pasar un ID
118                  * directamente.
119                  */
120                 PERR("Use directo");
121                 ID = clave.i_clave;
122                 block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
123         }
124         if ( block == EMUFS_NOT_FOUND ){
125                 PERR("No se encontro el bloque");
126                 *err = -1;
127                 return NULL;
128         }
129         
130         registro = (char*) malloc(emu->tam_reg);
131         if (registro == NULL) {
132                 PERR("No hay memoria");
133                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
134                 return NULL;
135         }
136
137         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
138         for (i=0; i<cant_bloques; i++){
139                 if ((bloque = emufs_tipo3_leer_bloque(emu, block+i, err)) == NULL) {
140                         /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
141                          * emufs_tipo3_leer_bloque() */
142                         PERR("no se pudo leer el bloque");
143                         free(registro);
144                         return NULL; /*No se pudo leer el bloque*/
145                 }
146                 ID_aux = -1;
147                 iterador = 0;
148                 while ( iterador < emu->tam_bloque ) {
149                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
150                         iterador += sizeof(EMUFS_REG_ID);
151                         if ( ID_aux == ID ){
152                                 if ( cant_bloques == 0 )
153                                         memcpy(registro,bloque+iterador,emu->tam_reg);
154                                 else {
155                                         if ( cant_bloques-1 == i ) 
156                                                 resto = emu->tam_reg - copiado;
157                                         memcpy(registro+(emu->tam_bloque-sizeof(EMUFS_REG_ID))*i,bloque+iterador,resto);
158                                         copiado += resto;
159                                         break;
160                                 }
161                                 *reg_size = emu->tam_reg;
162                         }
163                         iterador += emu->tam_reg;
164                 }
165                 free(bloque);
166         }
167
168         return registro;
169 }
170
171 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
172 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
173 {
174         FILE* file;
175         char* block; /* bloque leido (en donde está el registro a leer) */
176         char name_f[255];
177         
178         strcpy(name_f,emu->nombre);
179         strcat(name_f,".dat");
180         
181         if ((file = fopen(name_f, "r")) == NULL) {
182                 PERR("No se pudo abrir el archivo de datos");
183                 *err = EMUFS_ERROR_CANT_OPEN_FILE;
184                 return NULL;
185         }
186         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
187         /*FIXME: verificar que no se pase de fin de archivo*/
188         if (fseek(file,ID*emu->tam_bloque,SEEK_CUR) != 0){
189                 PERR("Fallo la busqueda del bloque");
190                 *err=3;
191                 return NULL;
192         }
193         
194         block = (char*) malloc(emu->tam_bloque);
195         if (block == NULL) {
196                 PERR("No hay memoria");
197                 *err = EMUFS_ERROR_OUT_OF_MEMORY;
198                 return NULL;
199         }
200         if (fread(block, emu->tam_bloque, 1, file) != 1) {
201                 /* TODO Manejo de errores */
202                 free(block);
203                 PERR("Error al leer bloque");
204                 *err = EMUFS_ERROR_FILE_READ;
205                 return NULL;
206         }
207
208         fclose(file);
209         return block;
210 }
211
212 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
213 {
214         INDICE_DATO idx_data;
215         EMUFS_REG_ID ID_aux;
216         EMUFS_FREE fs, new_fs;
217         EMUFS_BLOCK_ID num_bloque;
218         EMUFS_BLOCK_SIZE cant;
219         FILE *file;
220         char name_f[255];
221         char* bloque = NULL;
222         int cant_bloques, resto, i=0;
223         
224         strcpy(name_f,emu->nombre);
225         strcat(name_f,".dat");
226         
227         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
228         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque ) 
229                 cant_bloques = 1;
230         
231         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
232
233
234         
235         if ( cant_bloques == 1 ) 
236                 /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
237                 num_bloque = emufs_fsc_buscar_lugar(emu, emu->tam_reg+sizeof(EMUFS_REG_ID), &fs);
238         else 
239                 /* me devuelve el ID del bloque donde quepan n registros y el espacio libre en "fs"*/
240                 num_bloque = emufs_fsc_buscar_n_lugares(emu, cant_bloques, emu->tam_bloque, &fs, err);
241
242         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
243         if (num_bloque == EMUFS_NOT_FOUND) {
244                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
245                 /*tengo que buscar un ID valido para el nuevo registro*/
246                 ID_aux = emufs_idx_get_new_id(emu, err);
247                 /* El free esta al final de la funcion! */
248                 bloque = (char*)malloc(emu->tam_bloque);
249                 for (i=0; i<cant_bloques; i++) {
250                         /*crear un nuevo bloque en memoria */
251                         memset(bloque, 0, emu->tam_bloque);
252                         /* grabar el registro al principio del bloque */
253                         /*grabo el id en el bloque*/
254                         memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
255                         /*grabo el registro en el bloque*/
256                         if ( cant_bloques == 1 ){
257                                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
258                         } else {
259                                 if ( cant_bloques-1 == i )
260                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
261                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
262                         }
263                         /* me paro al final del archivo */
264                         fseek(file, 0, SEEK_END);
265                         /* grabo el bloque en el final del archivo */
266                         fwrite(bloque,emu->tam_bloque,1,file);
267                         /*tengo que buscar la cantidad de bloques que existen*/
268                         fseek(file, 0, SEEK_END); /* Me paro al final */
269                         cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
270                         cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
271                         num_bloque = cant;
272
273                         if (i == 0) {
274                                 /* Tengo que agregar el primer bloque en IDX */
275                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
276                                         free(bloque);
277                                         return -1;
278                                 }
279                                 idx_data.id = ID_aux;
280                                 idx_data.bloque = num_bloque;
281                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
282                         }
283                 
284                         /* grabo el nuevo registro en el archivo de espacios libres */
285                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ) 
286                                 new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - resto ;
287                         else new_fs = emu->tam_bloque - sizeof(EMUFS_REG_ID) - emu->tam_reg ;
288                         if ( emufs_fsc_agregar(emu, num_bloque+i, new_fs) ) {
289                                 fclose(file);
290                                 free(bloque);
291                                 return -1;
292                         }
293                 }
294                 fclose(file);
295         } else {
296                 /*tengo que buscar un ID valido para el nuevo registro*/
297                 ID_aux = emufs_idx_get_new_id(emu, err);
298                 for (i=0; i<cant_bloques; i++){
299                         resto = emu->tam_bloque-sizeof(EMUFS_REG_ID);
300                         /*cargo el bloque en "bloque"*/
301                         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
302                                 /* TODO Manejo de errores */
303                                 PERR("no se pudo leer el bloque");
304                                 return -1;
305                         }
306                         /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
307                         /*insertar el registro en el bloque*/
308                         /*grabo el id en el bloque*/
309                         /*veo el espacio libre que queda*/ 
310                         fs = emufs_fsc_get_fs(emu, num_bloque+i);
311                         if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
312                                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
313                         else
314                                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
315                         /*grabo el registro en el bloque*/
316                         if ( cant_bloques == 1 ){
317                                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
318                         } else {
319                                 if ( cant_bloques-1 == i )
320                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
321                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
322                         }                               
323                         
324                         /*grabo el bloque en el archivo*/
325                         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
326                                 PERR("error al grabar bloque");
327                                 if (bloque) free(bloque);
328                                 return -1; /* se produjo un error */    
329                         }
330                         
331                         /*actualizo el archivo de espacios libres*/
332                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ){
333                                 /*Si el registro ocupa mas de un bloque  (original) resto = emu->tam_bloque-sizeof(EMUFS_REG_ID)*/
334                                 resto += sizeof(EMUFS_REG_ID);
335                                 if ( cant_bloques-1 == i )
336                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID))+sizeof(EMUFS_REG_ID);
337                                 if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
338                                         fclose(file);
339                                         if (bloque) free(bloque);
340                                         return -1;
341                                 }
342                         } else {        
343                                 /* si ocupa menos de un bloque*/
344                                 resto = emu->tam_reg;
345                                 if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
346                                         fclose(file);
347                                         if (bloque) free(bloque);
348                                         return -1;
349                                 }
350                         }
351                         if ( i == 0 ){
352                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
353                                         if (bloque) free(bloque);
354                                         return -1;
355                                 }
356                                 idx_data.id = ID_aux;
357                                 idx_data.bloque = num_bloque;
358                                 emufs_indice_agregar(emu->indices, ptr, idx_data);
359                         }
360                 }
361         }
362         if (bloque) free(bloque);
363         return ID_aux;
364 }
365
366 /*Graba un bloque en el archivo*/
367 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
368 {
369         FILE* file;
370         char name_f[255];
371         
372         strcpy(name_f,emu->nombre);
373         strcat(name_f,".dat");
374         
375         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
376         /* Salto el header del archivo */
377         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
378         fseek(file, num*emu->tam_bloque, SEEK_CUR);     
379         fwrite(ptr, emu->tam_bloque, 1, file);
380         
381         fclose(file);
382         return 0;
383 }
384
385 /*borra un registro de un bloque y acomoda los registros que quedan*/
386 int emufs_tipo3_borrar_registro(EMUFS *emu, CLAVE k, INDICE_DATO dato1)
387 {
388         EMUFS_BLOCK_SIZE num_bloque;
389         EMUFS_BLOCK_SIZE ptr_elim;
390         EMUFS_BLOCK_SIZE ptr_mov;
391         EMUFS_REG_ID ID_aux, ID;
392         EMUFS_FREE fs;
393         INDICE_DATO dato;
394         char *bloque;
395         int err = 0, i, cant_bloques;
396
397         /*cantidad de bloques que ocupa un registro*/
398         cant_bloques = emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1;
399         if ( emu->tam_reg+sizeof(EMUFS_REG_ID) == emu->tam_bloque ) 
400                 cant_bloques = 1;
401
402         PERR("Buscando datos del registro en el indice");
403         if (emu->indices != NULL) {
404                 dato = emu->indices->existe_entrada(emu->indices, k);
405                 num_bloque = dato.bloque;
406                 ID = dato.id;
407         } else {
408                 ID = k.i_clave;
409                 num_bloque = emufs_idx_buscar_registro(emu, ID);
410         }
411
412         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
413                 /* TODO Manejo de errores */
414                 PERR("no se pudo leer el bloque");
415                 return -1;
416         }
417
418         /*apunto al registro que voy a eliminar*/
419         ptr_elim = 0;
420         while ( ptr_elim < emu->tam_bloque ){
421                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
422                 if ( ID_aux == ID )
423                         break;
424                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
425         }
426
427         /*apunto al registro que voy a mover*/
428         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
429         
430         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
431                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
432                 /* Blanqueo el area que movi */
433                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
434                 ptr_elim = ptr_mov;
435                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
436         }
437
438         /*grabo el bloque en el archivo*/       
439         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ) 
440                 memset(bloque, 0, emu->tam_bloque);
441         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
442                 free(bloque);
443                 PERR("No se pudo grabar el bloque"); 
444                 return -1;
445         }
446         
447         /*actualizo archivo .fsc*/
448         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg ) {
449                 for (i=0; i<cant_bloques; i++)
450                         if (emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque)) {
451                                 PERR("no se pudo agregar fsc"); 
452                                 free(bloque);
453                                 return -1;
454                         }
455         } else { 
456                 fs = emufs_fsc_get_fs(emu, num_bloque);
457                 if (emufs_fsc_agregar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID))) {
458                         PERR("no se pudo agregar fsc"); 
459                         free(bloque);
460                         return -1;
461                 }
462         }
463         /*actualizo archivo .did*/
464         if (emufs_did_agregar(emu, ID)) {
465                 PERR("no se pudo agregar did"); 
466                 free(bloque);
467                 return -1;
468         }
469                 
470         /*actualizo archivo .idx*/
471         if (emufs_idx_borrar(emu, ID)) {
472                 PERR("no se pudo agregar idx"); 
473                 free(bloque);
474                 return -1;
475         }
476
477         free(bloque);
478         PERR("Borrando claves");
479         emufs_indice_borrar(emu->indices, k, dato1);
480         PERR("Clave borrada de todos los indices");
481         return 0;
482 }
483
484 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
485 {
486         int err = 0,err1 = 0, err2 = 0, err3 = 0;
487         EMUFS_Estadisticas stats;
488         memset(&stats,0,sizeof(EMUFS_Estadisticas));
489         
490         { /* obtengo tamaño del archivo en bytes */
491                 char name_f[255];
492                 strcpy(name_f, emu->nombre);
493                 strcat(name_f, ".dat");
494                 stats.tam_archivo = emufs_common_get_file_size(name_f, &err);
495                 if (err) {
496                         PERR("no se pudo obtener el tamaño del archivo");
497                         return stats;
498                 }
499         }
500         
501         /* obtengo la cantidad de bloques en el archivo */
502         stats.cant_bloques = (stats.tam_archivo-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/
503                                                   emu->tam_bloque;
504
505         /* obtengo la cantidad de registros en el archivo */
506         {
507                 EMUFS_REG_ID *tmp = emufs_idx_get(emu, &stats.cant_registros);
508                 if (tmp) free(tmp); /* libera memoria innecesaria */
509         }
510
511         /* obtengo información de control que guarda el archivo .dat */
512         stats.tam_info_control_dat = stats.cant_registros*sizeof(EMUFS_REG_ID)+sizeof(EMUFS_Tipo)+
513                                                  sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE);
514
515         /* Obtengo las stats de FSC */
516         stats.total_fs = emufs_fsc_get_total_fs(emu);
517         stats.media_fs = emufs_fsc_get_media_fs(emu);
518         emufs_fsc_get_max_min_fs(emu,&stats.min_fs,&stats.max_fs);
519         
520         /* obtengo informacion de control guardada por los archivos auxiliares */
521         stats.tam_archivos_aux = emufs_idx_get_file_size(emu,&err1) + emufs_fsc_get_file_size(emu,&err2)
522                                                         + emufs_did_get_file_size(emu,&err3);
523         if (err1 || err2 || err3) {
524                 PERR("Hubo problemas en lectura de filesize archivos auxiliares");
525                 return stats;
526         }               
527
528         return stats;   
529 }
530
531 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, CLAVE k, void *data, EMUFS_REG_SIZE size, int *error, INDICE_DATO dato)
532 {
533         emufs_tipo3_borrar_registro(emu, k, dato);
534         return emufs_tipo3_grabar_registro(emu, data, size, error);
535 }
536
537 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
538 {
539         char* bloque;
540         EMUFS_BLOCK_ID block;
541         EMUFS_REG_ID ID_aux;
542         EMUFS_BLOCK_SIZE iterador = 0;
543         int err;
544         
545         bloque = NULL;
546                 
547         /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
548         block = emufs_idx_buscar_registro(emu,ID);
549         if ( block == EMUFS_NOT_FOUND ) {
550                 return NULL;
551         }
552         if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
553                 return NULL;
554         }
555                 
556         ID_aux = -1;
557         iterador = 0;
558         
559         /* Busco el offset desde el comienzo desde donde arranca el registro
560          * buscado, para luego resaltarlo en al GUI
561          */
562         while ( iterador < emu->tam_bloque ) {
563                 memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
564                 if ( ID_aux == ID ){
565                         *pos = iterador; 
566                         *size = emu->tam_bloque;
567                         break;
568                 }
569                 iterador += sizeof(EMUFS_REG_ID);
570                 iterador += emu->tam_reg;
571         }
572         return bloque;
573 }
574
575 void emufs_tipo3_compactar(EMUFS *emu)
576 {
577 /* TODO ARREGLAR */
578 #ifdef PEPITO_EL_GALAN 
579         EMUFS_REG_ID *tmp, max_id;
580         EMUFS_BLOCK_ID block_id;
581         EMUFS_REG_SIZE size;
582         EMUFS_FREE fs;
583         char name[255];
584         char *reg;
585         int err=0, ID_aux, i;
586         
587         strcpy(name, emu->nombre);
588         strcat(name, ".dat");
589
590         tmp = emufs_idx_get(emu, &max_id);
591         if (tmp) free(tmp);
592         for( i=0; i<max_id; i++){
593                 /* si el id no existe paso al siguiente*/
594                 if ( emufs_idx_existe_id(emu, i) != 0 ) continue;
595                 reg = emufs_tipo3_leer_registro(emu, i, &size, &err);
596                 if (err){
597                         PERR("No se pudo leer el registro para reacomodar");
598                         return;
599                 }
600                 emufs_tipo3_borrar_registro(emu, i);
601                 ID_aux = emufs_tipo3_grabar_registro(emu, reg, emu->tam_reg, &err);
602                 free(reg);
603         }
604         /*trunco el archivo sacando los bloques vacios*/
605         block_id = emufs_fsc_buscar_lugar(emu, emu->tam_bloque, &fs);
606         size = sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE)+block_id*emu->tam_bloque;
607         if (truncate(name, size)!=0)
608                 PERR("NO TRUNQUE NADA");
609         /*hay que truncar el fsc!!!*/
610         if(emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg) block_id = block_id/2;
611         if (emufs_fsc_truncate(emu, block_id)!= 0)
612                 PERR("NO TURNQUE EL FSC");
613 #endif
614 }
615
616 void emufs_tipo3_leer_bloque_raw(EMUFS *efs, EMUFS_BLOCK_ID id, char **actual, char **anterior, char **siguiente,
617                                                                  EMUFS_BLOCK_SIZE *size1, EMUFS_BLOCK_SIZE *size2, EMUFS_BLOCK_SIZE *size3)
618 {
619         int err;
620         (*actual) = emufs_tipo3_leer_bloque(efs, id, &err);
621         (*anterior) = emufs_tipo3_leer_bloque(efs, id-1, &err);
622         (*siguiente) = emufs_tipo3_leer_bloque(efs, id+1, &err);
623         if (!(*anterior)) {
624                 (*anterior) = (char *)malloc(efs->tam_bloque);
625                 memset(*anterior, 0, efs->tam_bloque);          
626         }       
627         if (!(*siguiente)) {
628                 (*siguiente) = (char *)malloc(efs->tam_bloque);
629                 memset(*siguiente, 0, efs->tam_bloque);         
630         }
631         (*size1) = (*size2) = (*size3) = efs->tam_bloque;
632 }
633
634 EMUFS_REG_ID emufs_tipo3_insertar_ordenado(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, int *err)
635 {
636         CLAVE clave, menor_clave_bloque_nuevo;
637         EMUFS_BLOCK_ID num_bloque; 
638         EMUFS_REG_ID header;
639         EMUFS_REG_SIZE tam_reg, move_size;
640         INDEX_DAT query;
641         EMUFS_FREE fs;
642         char *bloque = 0, *aux, *new_bloque = 0;
643         int cant_reg, i, result, dif;
644         
645         tam_reg = size;
646         /*le asigno un posible numero de bloque para el caso en que no encuentre donde meterlo*/
647         num_bloque = emufs_get_new_block_number(emu);   
648         query.num_bloque = num_bloque;
649         /*saco la clave del stream*/
650         query.clave = emufs_indice_generar_clave(emu->indices, ptr);
651         /*mando a buscar en el arbol el bloque correspondiente a esa clave*/
652         /*en query->num_bloque tengo el bloque donde debo meter el registro*/
653         /*debo insertar el reg en el bloque en forma ordenada*/
654         /*si es el menor de todos tengo que cambiar el ancla en el arbol*/
655         /*si no entra, tengo que insertar una nueva clave en el arbol y separar los registros en 2 bloques*/
656         /* emufs_b_plus_get_bloque retorna asi
657         -1 = Nuevo bloque, retorno idem num_bloque que ingreso
658         0 = Sin problemas, retorno bloque donde insertar
659         1 = Error de lectura en algun nodo, abortar operacion en funcion invocante.
660         */
661         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
662         if (result == 1){
663                 PERR("SE PRODUJO UN ERROR EN EL ARBOL.. ABORTANDO");
664                 return -1;
665         }
666         if ( result == -1 ){            
667                 /*creo un bloque nuevo*/
668                 bloque = (char*) malloc(emu->tam_bloque);
669                 if (bloque == NULL){
670                         PERR("NO SE PUDO CREAR EL BLOQUE");
671                         return -1;
672                 }
673                 memset(bloque, 0, emu->tam_bloque);
674                 header = emufs_idx_get_new_id(emu, err);
675                 if (*err) {
676                         PERR("NO SE PUDO OBTENER UN ID");
677                         free(bloque);
678                         return -1;
679                 }
680                 cant_reg = 1;
681                 /*pongo la cabecera en el registro*/
682                 memcpy(bloque, &header, sizeof(EMUFS_REG_ID)); 
683                 /*inserto el footer en el bloque*/
684                 memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
685                 /*inserto el registro en el bloqude*/
686                 if ( size <= emu->tam_bloque-sizeof(EMUFS_REG_ID)-sizeof(int) )
687                         memcpy(bloque+sizeof(EMUFS_REG_ID), ptr, size); 
688                 else {
689                         PERR("NO ENTRA EL REGISTRO EN EL BLOQUE!!!!!");
690                         free(bloque);
691                         return -1;
692                 }
693                 /*hago lugar en el archivo para grabar*/
694                 if ( num_bloque != emufs_create_new_block(emu) )        PERR("NUMEROS DE NUEVO BLOQUE DISTINTOS");
695                 /*grabo el bloque en el archivo*/ /* OJO CON LO DE FS = 0 */
696                 emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque);
697                 /*agrego la clave al arbol*/
698                 emufs_b_plus_insertar(emu->indices, &query);
699                 free(bloque);
700                 return header;
701         } else { /*tengo que meter el registro en el bloque que me dijo el arbol*/
702                 /*leo el bloque correspondiente*/
703                 bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
704                 /*me fijo cuantos registros hay en el */
705                 memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
706                 /*me fijo si entra en nuevo reg en el bloque */
707                 fs = emu->tam_bloque;
708                 aux = bloque;
709                 for (i=0; i<cant_reg; i++){
710                         aux += sizeof(EMUFS_REG_ID)+tam_reg;
711                         fs -= (tam_reg+sizeof(EMUFS_REG_ID));
712                 } /*aca deberia estar apuntando al final de los registros. espacio libre*/
713                 fs -= sizeof(int); /*footer*/
714                 if ( fs >= size+sizeof(EMUFS_REG_ID) ){ /* puedo meter el registro en este bloque*/
715                         PERR("GRABO ORDENADO");                 
716                         grabar_ordenado_en_bloque(emu, ptr, size, bloque, query.num_bloque, fs, err);
717                         /*en teoria el nuevo registro no debe cambiar el ancla, por lo cual no actualizo el arbol*/
718                         free(bloque);
719                         return header;
720                 } else { /* el registro no entra en el bloque, hay que crear uno nuevo y desparramar */
721                         PERR(" COMO NO ENTRA DEBO DIVIDIR LOS REGISTROS EN 2 BLOQUES");
722                         new_bloque = (char*)malloc(emu->tam_bloque);
723                         memset(new_bloque,0,emu->tam_bloque);
724                         move_size=0;
725                         aux = bloque;
726                         for(i=0; i<cant_reg/2; i++){ /*copio mitad-1 aca y mitad en el nuevo*/
727                                 /*avanzo*/
728                                 aux += sizeof(EMUFS_REG_ID)+tam_reg;
729                                 move_size += sizeof(EMUFS_REG_ID)+tam_reg;
730                         }/*apunto al reg mitad_mas_uno para copiar todo a otro bloque*/
731                         /*copio el resto del bloque al nuevo bloque*/      /*footer ¿?*/
732                         memcpy(new_bloque, aux, emu->tam_bloque-move_size-sizeof(int));
733                         /*borro lo que sobra en el bloque original, guardando el footer*/
734                         memset(aux, 0, emu->tam_bloque - move_size - sizeof(int));
735                         menor_clave_bloque_nuevo = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
736                         /* TENGO QUE VER EN CUAL DE LOS DOS BLOQUES METO EL REGISTRO NUEVO */
737                         if ( emufs_indice_es_menor(emu->indices, menor_clave_bloque_nuevo, clave) ){
738                                 /* GRABO EN EL BLOQUE NUEVO */
739                                 /*actualizo la cant de registros del bloque original (footer)*/
740                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
741                                 /*actualizo el footer del nuevo bloque*/
742                                 dif = cant_reg - i; /*por las dudas*/
743                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
744                                 /*genero un nuevo espacio para un bloque en el archivo y lo cargo en queryla clave ya estaba en query desde antes*/
745                                 num_bloque = query.num_bloque;
746                                 query.num_bloque = emufs_create_new_block(emu);
747                                 /*inserto el nuevo registro en el nuevo bloque y obtengo la clave del menor*/
748                                 clave = grabar_ordenado_en_bloque(emu,ptr,size,new_bloque,query.num_bloque, emu->tam_bloque-move_size,err);
749                                 /*actualizo el arbol con la nueva clave*/
750                                 query.clave = clave;
751                                 emufs_b_plus_insertar(emu->indices, &query);
752                                 /*grabo el bloque original*/
753                                 emufs_tipo3_grabar_bloque(emu, bloque, num_bloque);
754                         } else {
755                                 PERR("GRABO EN BLOQUE VIEJO");
756                                 /* GRABO EN EL BLOQUE VIEJO */
757                                 /*actualizo la cant de registros del bloque original (footer)*/
758                                 memcpy(bloque+emu->tam_bloque-sizeof(int), &i, sizeof(int));
759                                 /*actualizo el footer del nuevo bloque*/
760                                 dif = cant_reg - i; /*por las dudas*/
761                                 /*meto el footer en el reg */
762                                 memcpy(new_bloque+emu->tam_bloque-sizeof(int), &dif, sizeof(int));
763                                 /*guardo el num de bloque original */
764                                 num_bloque = query.num_bloque;
765                                 /* pido un bloque nuevo para guardar */
766                                 query.num_bloque = emufs_create_new_block(emu);
767                                 /*grabo el bloque nuevo*/
768                                 emufs_tipo3_grabar_bloque(emu, new_bloque, query.num_bloque);
769                                 /*grabo el registro en el bloque original*/
770                                 grabar_ordenado_en_bloque(emu,ptr,size,bloque,num_bloque,fs+move_size,err);
771                                 /*actualizo el arbol con la menor clave del bloque nuevo*/
772                                 query.clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
773                                 emufs_b_plus_insertar(emu->indices, &query);
774                         }
775                         if(*err != 0){
776                                 PERR("NO SE PUDO GRABAR ORDENADO");
777                                 free(new_bloque);
778                                 free(bloque);
779                                 return -1;
780                         }
781                         free(new_bloque);
782                         free(bloque);
783                         return header;
784                 }
785         }
786         if (new_bloque) free(new_bloque);
787         if (bloque) free(bloque);
788         return header;
789 }
790
791 /*inserta un registro ordenado en un bloque y devuelve la menor de las claves*/
792 CLAVE grabar_ordenado_en_bloque(EMUFS *emu, void *ptr, EMUFS_REG_SIZE size, void *bloque, int num_bloque, EMUFS_FREE fs, int *err)
793 {
794         char *aux, *new_bloque;
795         int cant_reg, tam_reg, i, j;
796         EMUFS_REG_ID header;
797         CLAVE clave, clave_ajena;
798
799         tam_reg = size; 
800         /*saco la cant de registros del bloque*/
801         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
802         /*obtengo la clave del nuevo registro*/
803         clave = emufs_indice_generar_clave(emu->indices, ptr);
804         /*cargo el header*/
805         header = emufs_idx_get_new_id(emu, err);
806         new_bloque = (char*)malloc(emu->tam_bloque);
807         memset(new_bloque, 0, emu->tam_bloque);
808         aux = new_bloque;
809         for (i=0; i<cant_reg+1; i++){
810                 bloque += sizeof(EMUFS_REG_ID); /*salteo el encabezado del registro*/
811                 if ( emu->tam_bloque-fs < sizeof(EMUFS_REG_ID)+emu->indices->offset ){
812                         PERR("ESTOY LEYENDO FUERA DEL BLOQUE!!!");
813                         free(new_bloque);
814                         *err = -1;
815                         return clave;
816                 }
817                 clave_ajena = emufs_indice_generar_clave(emu->indices, bloque); /*leo la clave*/
818                 bloque -= sizeof(EMUFS_REG_ID); /*vuelvo al principio*/
819                 if (  i<cant_reg && emufs_indice_es_menor(emu->indices, clave_ajena, clave) ){
820                         /*copio el reg al bloque nuevo*/
821                         memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
822                         bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*paso al proximo*/
823                         new_bloque += sizeof(EMUFS_REG_ID)+ tam_reg; /*dejo preparado*/
824                         continue;
825                 } else {
826                         /*meto el registro que me mandan*/
827                         memcpy(new_bloque, &header, sizeof(EMUFS_REG_ID));
828                         memcpy(new_bloque+sizeof(EMUFS_REG_ID), ptr, size);
829                         new_bloque += sizeof(EMUFS_REG_ID)+size;
830                         /*tengo que copiar los que faltan*/
831                         j = i;
832                         while ( j < cant_reg ){
833                                 memcpy(new_bloque, bloque, sizeof(EMUFS_REG_ID)+tam_reg);
834                                 bloque += sizeof(EMUFS_REG_ID)+tam_reg;
835                                 new_bloque += sizeof(EMUFS_REG_ID)+tam_reg;
836                                 j++;
837                         }
838                 break; /*corto el for porque ya inserte todos*/
839                 }
840         }
841         /*grabo el bloque en el archivo*/
842         new_bloque = aux; /*apunto al principio del bloque*/
843         cant_reg++; /*voy a poner un reg mas*/
844         memcpy(new_bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
845         emufs_tipo3_grabar_bloque(emu, new_bloque, num_bloque);
846         clave = emufs_indice_generar_clave(emu->indices, new_bloque+sizeof(EMUFS_REG_ID));
847         free(new_bloque);
848         return clave;
849 }
850
851 int emufs_tipo3_eliminar_ordenado(EMUFS *emu, CLAVE clave, INDICE_DATO dato)
852 {
853         char *bloque, *aux;
854         INDEX_DAT query;
855         int result, iter, cant_reg;
856         EMUFS_REG_SIZE tam_reg = emu->tam_reg;
857         CLAVE clave_ajena;
858         int err = 0;
859
860         /*cargo el query para buscar*/
861         query.num_bloque = 0;
862         query.clave = clave;
863         /*mando a buscar el bloque donde esta la clave que quiero eliminar*/
864         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
865         if ( result == 1 ){
866                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
867                 return -1;
868         }
869         if ( result == -1 ){
870                 PERR("NO EXISTE EL BLOQUE ¿?¿?¿?");
871                 return -1;
872         }
873         /*cargo el bloque que corresponde*/
874         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, &err);
875         if ( bloque == NULL ){
876                 PERR("NO SE CARGO EL BLOQUE");
877                 return -1;
878         }
879         /*leo la cantidad de registros en el bloque*/
880         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
881         /*busco y elimino*/
882         iter = 0;
883         aux = bloque;
884         /*me fijo si el que tengo que eliminar es el ancla del bloque*/
885         clave_ajena = emufs_indice_generar_clave(emu->indices, bloque+sizeof(EMUFS_REG_ID));
886         if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
887                 /* TENGOQ QUE BORRAR LA CLAVE DEL ARBOL !!!!*/
888                 /* Y HAY QUE BORRAR EL BLOQUE DEL ARCHIVO*/
889         }
890         while ( iter < emu->tam_bloque ){
891                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
892                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
893                         /*tenngo que borrar este registro*/
894                         /*limpio el espacio que ocupaba*/
895                         memset(aux, 0, tam_reg+sizeof(EMUFS_REG_ID));
896                         /*hay que reacomodar todo*/
897                         /*me posiciono en el reg siguiente*/
898                         iter += tam_reg+sizeof(EMUFS_REG_ID);
899                         break;/*ya borre, corto aca*/
900                 }
901                 iter += tam_reg+sizeof(EMUFS_REG_ID);
902                 aux += tam_reg+sizeof(EMUFS_REG_ID);
903         }
904         /*reacomodo el bloque */
905         memcpy(aux, aux+tam_reg+sizeof(EMUFS_REG_ID), emu->tam_bloque-iter-sizeof(int));
906         /*le vuelvo a copiar la cantidad de registros*/
907         cant_reg--;
908         memcpy(bloque+emu->tam_bloque-sizeof(int), &cant_reg, sizeof(int));
909         /*grabo el bloque en el archivo*/
910         if ( emufs_tipo3_grabar_bloque(emu, bloque, query.num_bloque) == -1){
911                 PERR("NO SE PUDO GRABAR EL BLOQUE");
912                 free(bloque);
913                 return -1;
914         }
915         free(bloque);
916         return 0;
917 }
918
919 void *emufs_tipo3_leer_registro_plus(EMUFS *emu, CLAVE clave, EMUFS_REG_SIZE *size, int *err)
920 {
921         CLAVE clave_ajena;
922         char *reg = NULL; 
923         char *bloque, *aux;
924         INDEX_DAT query;
925         int result, cant_reg, i;
926         EMUFS_REG_SIZE tam_reg;
927         
928         tam_reg = emu->tam_reg;
929         /*cargo el query*/
930         query.clave = clave;
931         query.num_bloque = 0;
932         /*hago la consulta*/
933         
934         result = emufs_b_plus_get_bloque(emu->indices, &query, 0);
935         if (result == -1){
936                 PERR("NO EXISTE EL BLOQUE");
937                 return NULL;
938         }
939         if (result == 1){
940                 PERR("SE PRODUJO UN ERROR EN EL ARBOL");
941                 return NULL;
942         }
943         /*leo el bloque*/
944         bloque = emufs_tipo3_leer_bloque(emu, query.num_bloque, err);
945         /*busco el registro en el bloque*/
946         /*copio la cantidad de registros*/
947         memcpy(&cant_reg, bloque+emu->tam_bloque-sizeof(int), sizeof(int));
948         aux = bloque;
949         for (i=0; i<cant_reg; i++){
950                 /*leo la clave*/
951                 clave_ajena = emufs_indice_generar_clave(emu->indices, aux+sizeof(EMUFS_REG_ID));
952                 if ( emufs_indice_es_igual(emu->indices, clave, clave_ajena) ){
953                         reg = (char*)malloc(tam_reg);
954                         if (reg == NULL){
955                                 PERR("NO SE PUDO CARGAR EL REGISTRO");
956                                 *err = -1;
957                                 free(bloque);
958                                 return NULL;
959                         }
960                         /*copio el registro*/
961                         memcpy(reg, aux+sizeof(EMUFS_REG_ID), tam_reg);
962                         *size = tam_reg;
963                         break; /*ya lo encontre, corto el for*/
964                 }
965                 aux += tam_reg+sizeof(EMUFS_REG_ID); /*paso al proximo*/
966         }
967         if ( i == cant_reg ) *err=-1;
968         free(bloque);
969         return reg;
970 }
971
972
973 EMUFS_REG_ID emufs_tipo3_modificar_registro_plus(EMUFS *emu, CLAVE k, void *ptr , EMUFS_REG_SIZE size, int* err, INDICE_DATO dato)
974 {
975         emufs_tipo3_eliminar_ordenado(emu, k, dato);
976         return emufs_tipo3_insertar_ordenado(emu, ptr, size, err);
977 }