]> git.llucax.com Git - z.facultad/75.06/emufs.git/blob - emufs/tipo2.c
* BUGFIX : cuando se recreaba con otro formato el archivo de
[z.facultad/75.06/emufs.git] / emufs / tipo2.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:  Fri Apr 10 17:10:00 ART 2004
22  * Autores: Alan Kennedy <kennedya@3dgames.com.ar>
23  *----------------------------------------------------------------------------
24  *
25  * $Id: tipo3.c 85 2004-04-08 23:39:28Z sagar $
26  *
27  */
28
29 /** \file
30  * Archivo con registros de longitud variable, sin bloques.
31  *
32  * <b>Implementacion del Archivo Tipo 2</b>
33  *
34  * La organizacion interna de un archivo de tipo 2, presenta registros de longitud variable,
35  * los cuales son grabados secuencialmente, o bien en gaps (espacios libres) que se presenten en
36  * el archivo de datos, pero no se encuentran contenidos por bloques.
37  *
38  */
39
40 #include "tipo2.h"
41 #include "idx.h"
42 #include "fsc.h"
43 #include "did.h"
44
45 /* Asigna los punteros a las funciones apropiadas para el Tipo2 */
46 int emufs_tipo2_inicializar(EMUFS* efs)
47 {
48         efs->grabar_registro = emufs_tipo2_grabar_registro;           
49     efs->borrar_registro = emufs_tipo2_borrar_registro;
50         efs->leer_registro = emufs_tipo2_leer_registro;
51         efs->modificar_registro = emufs_tipo2_modificar_registro;
52         efs->leer_estadisticas = emufs_tipo2_leer_estadisticas;
53         
54         return 0;
55 }
56
57 /* Lee y devuelve un registro de un archivo del Tipo 2. */
58 void *emufs_tipo2_leer_registro(EMUFS* efs, EMUFS_REG_ID id_reg, EMUFS_REG_SIZE* reg_size, int *err)
59 {
60         FILE* f_data;
61         char *registro; /* registro a leer */
62         char  name_f[255];      
63         EMUFS_OFFSET reg_offset; /* offset donde se encuentra el registro */
64         
65         strcpy(name_f,efs->nombre);
66         strcat(name_f,".dat");
67
68         /* Obtenemos la posicion del registro en el .dat */
69         reg_offset = emufs_idx_buscar_registro(efs, id_reg);
70         if (reg_offset == EMUFS_NOT_FOUND) {
71                 /* TODO Manejo de errores */
72                 PERR("Registro no encontrado");
73                 *err = EMUFS_NOT_FOUND;
74                 return NULL;
75         }
76         
77         /* Levantamos el registro */
78         if ((f_data = fopen(name_f, "rb")) == NULL) {
79                 PERR("No se puede abrir archivo");
80                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
81                 return NULL; /* FIXME ERROR */
82         }
83         fseek(f_data,reg_offset+sizeof(EMUFS_REG_ID),0);
84         fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
85         registro = (char*)malloc(*reg_size);
86         fread(registro,*reg_size,1,f_data);
87         fclose(f_data);
88         
89         return registro;
90 }
91
92 /* Grabar un registro en un archivo del Tipo 2. */
93 EMUFS_REG_ID emufs_tipo2_grabar_registro(EMUFS *efs, void *ptr, EMUFS_REG_SIZE reg_size, int* err)
94 {
95         EMUFS_REG_ID id_reg;
96         EMUFS_FREE freespace;
97         EMUFS_OFFSET wrt_offset,reg_offset;
98         unsigned long int fisic_size;
99         FILE *f_data;
100         char name_f[255];
101         
102         /* Armamos el filename del archivo de datos */
103         strcpy(name_f,efs->nombre);
104         strcat(name_f,".dat");
105         
106         if ( (f_data = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
107         
108         /* Obtengo un offset en donde iniciar la escritura de mi registro */
109         /* de manera segura (habra espacio suficiente) */
110         fisic_size = sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE)+reg_size;
111         wrt_offset = emufs_fsc_buscar_lugar(efs,fisic_size,&freespace);
112         /*printf("tipo2.c >> Recording Reg > Searching FSC: Offset = %lu FSpace: %lu\n", n_WrtOffset, n_FreeSpace);*/
113         
114         /* Si no encontre un gap, entonces escribo el registro al final */
115         if (wrt_offset == -1) {                
116                 
117                 /* Obtengo un ID libre para el registro y luego grabo a disco */
118                 id_reg = emufs_idx_get_new_id(efs, err);
119                 fseek(f_data, 0, SEEK_END);
120                 reg_offset = ftell(f_data);
121
122                 /* Escribo [RegId]|[RegSize]|[RegData] */
123                 fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
124                 fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
125                 fwrite(ptr,reg_size,1,f_data);
126                                 
127                 /* Bye */
128                 /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/
129                 fclose(f_data);
130                 
131         } else {
132                 
133                 /* Obtengo un ID libre para el registro y luego grabo en disco */
134                 id_reg = emufs_idx_get_new_id(efs, err);
135                 reg_offset = wrt_offset;
136                 fseek(f_data,reg_offset,0);
137                 
138     /* Escribo [RegId]|[RegSize]|[RegData] */
139                 fwrite(&id_reg,sizeof(EMUFS_REG_ID),1,f_data);
140                 fwrite(&reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);
141                 fwrite(ptr,reg_size,1,f_data);
142                                 
143                 /* Bye */
144                 /*printf("Tipo2.c >> RegNr: %lu with FisicSize: %lu inserted at Offset: %lu\n",n_IdReg,n_FisicSize,n_RegOffset);*/
145                 fclose(f_data);
146                 
147                 /* Actualizo el espacio libre en el GAP donde puse el registro */
148                 if ((freespace-fisic_size) == 0) emufs_fsc_remove_gap(efs,reg_offset);
149                 else emufs_fsc_actualizar_gap(efs,reg_offset,freespace-fisic_size);             
150         }
151                 
152         /* Finalmente, actualizamos el indice de registros (offsets) */
153         emufs_idx_agregar(efs,id_reg,reg_offset);
154                 
155         return id_reg;
156 }
157
158 /* Borra un registro determinado y actualiza los archivos de Posicion Relativa (Indice-Offset) y el de Gaps */
159 int emufs_tipo2_borrar_registro(EMUFS *efs, EMUFS_REG_ID id_reg)
160 {       
161         EMUFS_OFFSET reg_offset,reg_size;
162          
163         /* Obtenemos el offset donde arranca el registro */
164         if ((reg_offset = emufs_idx_buscar_registro(efs,id_reg)) == EMUFS_NOT_FOUND) {
165                 /* TODO Manejo de errores */
166                 PERR("Registro no encontrado");
167                 return EMUFS_NOT_FOUND;
168         }
169         
170         /* Obtenemos el Size del Registro en cuestion y hacemos un dummyfill*/
171         emufs_tipo2_get_regsize(efs,reg_offset,&reg_size);      
172         emufs_tipo2_dummyfill(efs,reg_offset,reg_size);
173                 
174         /* Agregamos el GAP en el archivo de FSC, el cual hara un merge con */
175         /* otro GAP por delante y/o por detras en caso de hallarlo. */
176         emufs_fsc_agregar_gap(efs,reg_offset,reg_size+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE));
177         
178         /* Agrego el ID que se ha liberado al archivo de ID's Libres */
179         emufs_did_agregar(efs,id_reg);  
180         
181         /* Borramos el registro del indice de posiciones relativas */
182         emufs_idx_borrar(efs,id_reg);
183         
184         return(0);
185 }
186
187 /* Devuelve el tamanio de un registro, dado su init offset */
188 int emufs_tipo2_get_regsize(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE *reg_size)
189 {
190     FILE *f_data;
191         char name_f[255];
192
193     /* Armamos el filename del archivo de datos */
194         strcpy(name_f,efs->nombre);
195         strcat(name_f,".dat");
196
197     if ((f_data = fopen(name_f,"r+")) == NULL) return -1; /* ERROR */
198         fseek(f_data,reg_pos+sizeof(EMUFS_REG_ID),SEEK_SET);
199         fread(reg_size,sizeof(EMUFS_REG_SIZE),1,f_data);                
200         fclose(f_data);
201         
202         return (0);
203 }
204
205
206 /* Pisa con basura lo que es hasta el momento un reg en el disco para indicar su borrado (Debug Purposes Only) */
207 int emufs_tipo2_dummyfill(EMUFS *efs, EMUFS_OFFSET reg_pos, EMUFS_REG_SIZE amount)
208 {
209         FILE *f_data;
210         char name_f[255];
211         char *dummyfill;
212         char *ptr_cur;
213         unsigned long fill_size,byte_count;
214         
215         /* Armamos el filename del archivo de datos */
216         strcpy(name_f,efs->nombre);
217         strcat(name_f,".dat");
218
219         if ((f_data = fopen(name_f,"rb+")) == NULL) return -1; /* ERROR */
220         
221         /* Preparo el garbage y se lo tiro encima */
222         fill_size = amount+sizeof(EMUFS_REG_ID)+sizeof(EMUFS_REG_SIZE);
223         dummyfill = (char*)malloc(fill_size);
224         memset(dummyfill, 0, fill_size);
225         ptr_cur = dummyfill;
226         for (byte_count = 0; byte_count < fill_size; ++byte_count) memcpy(ptr_cur+byte_count,0,1);
227         fseek(f_data,reg_pos,SEEK_SET);
228         fwrite(dummyfill,fill_size,1,f_data);
229         fclose(f_data);
230         
231         free(dummyfill);
232         return (0);
233 }
234
235 /* Realiza la actualizacin de un registro ya existente */
236 EMUFS_REG_ID emufs_tipo2_modificar_registro(EMUFS *efs, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
237 {
238         emufs_tipo2_borrar_registro(efs, id);
239         return emufs_tipo2_grabar_registro(efs, data, size, error);
240 }
241
242 /* Recompila y devuelve ciertas estadisticas del archivo indicado */
243 EMUFS_Estadisticas emufs_tipo2_leer_estadisticas(EMUFS *efs)
244 {
245     EMUFS_Estadisticas stats;
246         EMUFS_REG_ID *tmp;
247         unsigned long fsc_size = 0,idx_size = 0;
248         char name_f[255];
249         FILE *file;
250
251         strcpy(name_f,efs->nombre);
252         strcat(name_f,".dat");
253         
254         /* Inicializo las stats por si hay error somewhere */
255         stats.tam_archivo = 0;
256         stats.tam_archivo_bytes = 0;
257         stats.info_control = 0;
258         stats.media_fs = 0;
259         stats.total_fs = 0;
260         stats.max_fs = 0;
261         stats.min_fs = 0;
262         stats.cant_bloques = 0;
263         
264         /* Obtengo las stats de FSC */
265         stats.total_fs = emufs_fsc_get_total_fs(efs);
266         stats.media_fs = emufs_fsc_get_media_fs(efs);
267         emufs_fsc_get_max_min_fs(efs,&stats.min_fs,&stats.max_fs);
268         
269         /* Cant registros */
270         tmp = emufs_idx_get(efs,&stats.tam_archivo);
271         free(tmp);
272         
273         /* Size del archivo de datos */
274         if ( (file = fopen(name_f,"ab")) == NULL){
275                         PERR("No se pudo abrir el archivo");
276                         return stats;   
277         }
278         stats.tam_archivo_bytes = ftell(file);
279         fclose(file);
280
281         /* Size del archivo de Espacio Libre */ 
282         strcpy(name_f,efs->nombre);
283         strcat(name_f,EMUFS_FSC_EXT);
284         if ( (file = fopen(name_f,"ab")) == NULL){
285             PERR("No se pudo abrir el archivo");
286                 return stats;   
287         }
288         fsc_size = ftell(file);
289         fclose(file);
290         
291         /* Size del archivo Indice */   
292         strcpy(name_f,efs->nombre);
293         strcat(name_f,EMUFS_IDX_EXT);
294         if ( (file = fopen(name_f,"ab")) == NULL){
295             PERR("No se pudo abrir el archivo");
296                 return stats;   
297         }
298         idx_size = ftell(file);
299         fclose(file);
300         
301         /* Cantidad de Bytes en info de control */
302         stats.info_control = idx_size + fsc_size + sizeof(EMUFS_REG_ID)*stats.tam_archivo + sizeof(EMUFS_REG_SIZE)*stats.tam_archivo + sizeof(EMUFS_Tipo);
303         
304         return(stats);  
305 }
306
307 /* Recompila y devuelve ciertas estadisticas del archivo indicado */
308 int emufs_tipo2_recompactar(EMUFS *efs)
309 {
310         char name_fdat[255],name_ffsc[255];
311         FILE *datfile;
312         FILE *fscfile;
313         EMUFS_FSC reg1,reg2;
314         unsigned long cant_gaps = 0,mustmove_bytes = 0,source = 0,
315                                   destination = 0,datsize = 0,totalfsc = 0;
316         
317         strcpy(name_fdat,efs->nombre);
318         strcpy(name_ffsc,efs->nombre);
319         strcat(name_fdat,".dat");
320         strcat(name_ffsc,EMUFS_FSC_EXT);
321         
322         /* Obtengo el tamanio del .dat */
323         if ( (datfile = fopen(name_fdat,"rb+")) == NULL){
324                         PERR("No se pudo abrir el archivo");
325                         return -1;      
326         }
327         fseek(datfile,0,SEEK_END);
328         datsize = ftell(datfile);
329         
330         /* Obtengo la cantidad de gaps */
331         if ( (fscfile = fopen(name_ffsc,"rb")) == NULL){
332                         PERR("No se pudo abrir el archivo");
333                         return -1;      
334         }
335         fseek(fscfile,0,SEEK_END);
336         cant_gaps = ftell(fscfile)/sizeof(EMUFS_FSC);
337         
338         if (cant_gaps == 0) return 0;
339         if (cant_gaps == 1) {
340                 /* Un solo gap, muevo toda la data luego del gap y trunco */
341                 fseek(fscfile,0,SEEK_SET);
342                 fread(&reg1,sizeof(EMUFS_FSC),1,fscfile);       
343                 source = reg1.marker + reg1.freespace;
344                 destination = reg1.marker;
345                 mustmove_bytes = datsize - source;
346                 /*printf("Para recompactar, must move: %lu bytes\n",mustmove_bytes);
347                 printf("Will move from: %lu  to  %lu\n",source,destination);*/
348                 emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
349         }
350         if (cant_gaps > 1)
351         {
352                 /* Comienzo leyendo un gap */
353                 fseek(fscfile,0,SEEK_SET);
354                 fread(&reg1,sizeof(EMUFS_FSC),1,fscfile);
355                 destination = reg1.marker;
356                 --cant_gaps;
357                 
358                 while (cant_gaps > 0)
359                 {
360                         /* El source siempre sera el fin del anteultimo gap leido */
361                         source = reg1.marker + reg1.freespace;
362                         /* Leemos otro gap para calcular cuanto debemos mover */
363                         fread(&reg2,sizeof(EMUFS_FSC),1,fscfile);
364                         mustmove_bytes = reg2.marker - source;
365                         /*printf("Para recompactar, must move: %lu bytes\n",mustmove_bytes);
366                         printf("Will move from: %lu  to  %lu\n",source,destination);*/
367                         emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
368                         /* Guardo el nuevo destino que es donde termino de mover */
369                         destination = ftell(datfile);
370                         /* El ultimo gap leido, pasa a ser el de referencia ahora */
371                         reg1.marker = reg2.marker;
372                         reg1.freespace = reg2.freespace;
373                         --cant_gaps;
374                 }
375                 
376                 /* Realizo el movimiento del ultimo chunk de datos */
377                 source = reg1.marker + reg1.freespace;
378                 mustmove_bytes = datsize - source;
379                 emufs_tipo2_movedata(datfile,&source,&destination,mustmove_bytes);
380         }
381                 
382         fclose(datfile);
383         fclose(fscfile);
384         
385         /* Trunco el dat para que no quede el espacio vacio al final */
386         totalfsc = emufs_fsc_get_total_fs(efs);
387         truncate(name_fdat,datsize - totalfsc);
388         truncate(name_ffsc,0);
389         return 0;
390 }
391
392 void emufs_tipo2_movedata(FILE *datfile,EMUFS_OFFSET *source, EMUFS_OFFSET *destination, EMUFS_BLOCK_SIZE mustmove_bytes)
393 {
394     int chunksize = 9;
395         char *chunk = malloc(chunksize*sizeof(char));
396         unsigned long cant_chunks = 0,left_chunk = 0;
397         
398         /* Obtengo cuantos bloques de a CHUNKSIZE bytes debo mover. Si la cantidad es no entera */
399         cant_chunks = floor(mustmove_bytes/chunksize);
400         left_chunk = fmod(mustmove_bytes,chunksize);
401         
402         /*printf ("Cantidad de chunk de %i bytes movidos: %lu\n",chunksize,cant_chunks);
403         printf ("Left chunk movido fue de: %lu bytes\n",left_chunk);*/
404         
405         while(cant_chunks > 0)
406         {
407                 fseek(datfile,*source,SEEK_SET);
408                 fread(chunk,chunksize,1,datfile);
409                 fseek(datfile,*destination,SEEK_SET);
410                 fwrite(chunk,chunksize,1,datfile);
411                 *source += chunksize;
412                 *destination += chunksize;              
413                 --cant_chunks;
414         }
415         
416         if (left_chunk > 0)
417         {
418                 fseek(datfile,*source,SEEK_SET);
419                 fread(chunk,left_chunk,1,datfile);
420                 fseek(datfile,*destination,SEEK_SET);
421                 fwrite(chunk,left_chunk,1,datfile);
422         }
423         
424         free(chunk);
425 }