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
  40 /** Leo un registro del archivo, devuelve cero si no lo encuentra.**/
  41 void* emufs_tipo3_leer_registro(EMUFS *emu, EMUFS_REG_ID ID,
  42                 EMUFS_REG_SIZE* reg_size, int* err)
  43 {
  44         char* bloque;
  45         char* registro; /* registro a leer */
  46         EMUFS_BLOCK_ID block;
  47         EMUFS_REG_ID ID_aux;
  48         EMUFS_BLOCK_SIZE iterador = 0;
  49         int cant_bloques = 0, resto, i, copiado=0;
  50
  51         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
  52
  53         /*si existe, lo busco en el archivo de bloques*/
  54         block = emufs_idx_buscar_registro(emu,ID); /*me devuelve el nro de bloque al que pertenece el registro*/
  55         if ( block == EMUFS_NOT_FOUND ){
  56                 PERR("No se encontro el bloque");
  57                 *err = -1;
  58                 return NULL;
  59         }
  60
  61         registro = (char*) malloc(emu->tam_reg);
  62         if (registro == NULL) {
  63                 /* TODO Manejo de errores */
  64                 free(bloque);
  65                 PERR("No hay memoria");
  66                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
  67                 return NULL;
  68         }
  69
  70         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
  71         for (i=0; i<cant_bloques; i++){
  72                 if ((bloque = emufs_tipo3_leer_bloque(emu, block+i, err)) == NULL) {
  73                         /* TODO Manejo de errores, queda en el codigo de error lo que devolvio
  74                          * emufs_tipo3_leer_bloque() */
  75                         PERR("no se pudo leer el bloque");
  76                         return NULL; /*No se pudo leer el bloque*/
  77                 }
  78                 ID_aux = -1;
  79                 iterador = 0;
  80                 while ( iterador < emu->tam_bloque ) {
  81                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
  82                         iterador += sizeof(EMUFS_REG_ID);
  83                         if ( ID_aux == ID ){
  84                                 if ( cant_bloques == 0 )
  85                                         memcpy(registro,bloque+iterador,emu->tam_reg);
  86                                 else {
  87                                         if ( cant_bloques-1 == i )
  88                                                 resto = emu->tam_reg - copiado;
  89                                         memcpy(registro+(emu->tam_bloque-sizeof(EMUFS_REG_ID))*i,bloque+iterador,resto);
  90                                         copiado += resto;
  91                                         break;
  92                                 }
  93                                 *reg_size = emu->tam_reg;
  94                         }
  95                         iterador += emu->tam_reg;
  96                 }
  97                 free(bloque);
  98         }
  99
 100         return registro;
 101 }
 102
 103 /*leo el bloque "ID" del archivo que viene en "emu->nombre", y lo almaceno en "ptr"*/
 104 void* emufs_tipo3_leer_bloque(EMUFS *emu, EMUFS_BLOCK_ID ID, int* err)
 105 {
 106         FILE* file;
 107         char* block; /* bloque leido (en donde está el registro a leer) */
 108         char name_f[255];
 109
 110         strcpy(name_f,emu->nombre);
 111         strcat(name_f,".dat");
 112
 113         if ((file = fopen(name_f, "r")) == NULL) {
 114                 PERR("No se pudo abrir el archivo de datos");
 115                 *err = 4; /* EMUFS_ERROR_CANT_OPEN_FILE */
 116                 return NULL; /* FIXME ERROR */
 117         }
 118         fseek(file,sizeof(EMUFS_Tipo)+sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE),SEEK_SET);
 119         /*FIXME: verificar que no se pase de fin de archivo*/
 120         if (fseek(file,ID*emu->tam_bloque,SEEK_CUR) != 0){
 121                 PERR("Fallo la busqueda del bloque");
 122                 *err=3;
 123                 return NULL;
 124         }
 125
 126         block = (char*) malloc(emu->tam_bloque);
 127         if (block == NULL) {
 128                 /* TODO Manejo de errores */
 129                 PERR("No hay memoria");
 130                 *err = 2; /* EMUFS_ERROR_OUT_OF_MEMORY */
 131                 return NULL;
 132         }
 133         if (fread(block, emu->tam_bloque, 1, file) != 1) {
 134                 /* TODO Manejo de errores */
 135                 free(block);
 136                 PERR("Error al leer bloque");
 137                 *err = 3; /* EMUFS_ERROR_FILE_READ */
 138                 return NULL;
 139         }
 140
 141         fclose(file);
 142         return block;
 143 }
 144
 145 EMUFS_REG_ID emufs_tipo3_grabar_registro(EMUFS *emu, void *ptr, EMUFS_REG_SIZE tam, int* err)
 146 {
 147         EMUFS_REG_ID ID_aux;
 148         EMUFS_FREE fs;
 149         EMUFS_BLOCK_ID num_bloque;
 150         EMUFS_BLOCK_SIZE cant;
 151         FILE *file;
 152         char name_f[255];
 153         char* bloque;
 154         int cant_bloques, resto, i=0, lugar;
 155
 156         strcpy(name_f,emu->nombre);
 157         strcat(name_f,".dat");
 158
 159         cant_bloques = (emu->tam_reg / (emu->tam_bloque-sizeof(EMUFS_REG_ID))) + 1;
 160         resto = emu->tam_bloque - sizeof(EMUFS_REG_ID);
 161         lugar = emu->tam_reg + sizeof(EMUFS_REG_ID);
 162         if ( emu->tam_bloque < emu->tam_reg - sizeof(EMUFS_REG_ID) )
 163                 lugar = emu->tam_bloque;
 164         /* me devuelve el ID del bloque donde quepa un registro y el espacio libre en "fs"*/
 165         num_bloque = emufs_fsc_buscar_lugar(emu, lugar, &fs);
 166         /*si no hay bloques con suficiente espacio creo un bloque nuevo */
 167         if (num_bloque == -1) {
 168                 if ( (file = fopen(name_f,"a+"))==NULL ) return -1; /*ERROR*/
 169                 /*tengo que buscar un ID valido para el nuevo registro*/
 170                 ID_aux = emufs_idx_get_new_id(emu, err);
 171                 /* El free esta al final de la funcion! */
 172                 bloque = (char*)malloc(emu->tam_bloque);
 173                 for (i=0; i<cant_bloques; i++) {
 174                         /*crear un nuevo bloque en memoria */
 175                         memset(bloque, 0, emu->tam_bloque);
 176                         /* grabar el registro al principio del bloque */
 177                         /*grabo el id en el bloque*/
 178                         memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 179                         /*grabo el registro en el bloque*/
 180                         if ( cant_bloques == 1 ){
 181                                 memcpy(bloque+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 182                         } else {
 183                                 if ( cant_bloques-1 == i )
 184                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 185                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 186                         }
 187                         /* me paro al final del archivo */
 188                         fseek(file, 0, SEEK_END);
 189                         /* grabo el bloque en el final del archivo */
 190                         fwrite(bloque,emu->tam_bloque,1,file);
 191                         /*actualizo el archivo de espacios libres*/
 192                         /*tengo que buscar la cantidad de bloques que existen*/
 193                         fseek(file, 0, SEEK_END); /* Me paro al final */
 194                         cant = (ftell(file)-(sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE))) / emu->tam_bloque;
 195                         cant--; /* Resto uno porque el numero de bloque debe empezar en 0 */
 196                         num_bloque = cant;
 197
 198                         if (i == 0) {
 199                                 /* Tengo que agregar el primer bloque en IDX */
 200                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 201                                         free(bloque);
 202                                         return -1;
 203                                 }
 204                         }
 205
 206                         /* grabo el nuevo registro en el archivo de espacios libres */
 207                         if ( emu->tam_bloque > emu->tam_reg ) resto = emu->tam_reg;
 208                         if ( emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque - resto - sizeof(EMUFS_REG_ID)) != 0 ) {
 209                                 fclose(file);
 210                                 free(bloque);
 211                                 return -1;
 212                         }
 213
 214                 }
 215                 fclose(file);
 216         } else {
 217                 /*tengo que buscar un ID valido para el nuevo registro*/
 218                 ID_aux = emufs_idx_get_new_id(emu, err);
 219                 for (i=0; i<cant_bloques; i++){
 220                         /*cargo el bloque en "bloque"*/
 221                         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque+i, err))) {
 222                                 /* TODO Manejo de errores */
 223                                 PERR("no se pudo leer el bloque");
 224                                 return -1;
 225                         }
 226                         /*El error puede haberse producido porque la funcion leer_bloque devolvio -1, el cual es un bloque invalido*/
 227                         /*insertar el registro en el bloque*/
 228                         /*grabo el id en el bloque*/
 229                         /*veo el espacio libre que queda*/
 230                         fs = emufs_fsc_get_fs(emu, num_bloque+i);
 231                         if (emu->tam_bloque-sizeof(EMUFS_REG_ID) < emu->tam_reg)
 232                                 memcpy(bloque,&ID_aux,sizeof(EMUFS_REG_ID));
 233                         else
 234                                 memcpy(bloque+emu->tam_bloque-fs,&ID_aux,sizeof(EMUFS_REG_ID));
 235                         /*grabo el registro en el bloque*/
 236                         if ( cant_bloques == 1 ){
 237                                 memcpy(bloque+emu->tam_bloque-fs+sizeof(EMUFS_REG_ID),ptr,emu->tam_reg);
 238                         } else {
 239                                 if ( cant_bloques-1 == i )
 240                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 241                                 memcpy(bloque+sizeof(EMUFS_REG_ID),((char*)ptr)+i*(emu->tam_bloque-sizeof(EMUFS_REG_ID)),resto);
 242                         }
 243
 244                         /*grabo el bloque en el archivo*/
 245                         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque+i) != 0) {
 246                                 PERR("error al grabar bloque");
 247                                 return -1; /* se produjo un error */
 248                         }
 249
 250                         /*actualizo el archivo de espacios libres*/
 251                         if ( emu->tam_bloque-sizeof(EMUFS_REG_ID) > emu->tam_reg ){
 252                                 resto = emu->tam_reg;
 253                                 if ( emufs_fsc_agregar(emu, num_bloque, fs - resto - sizeof(EMUFS_REG_ID) ) != 0 ) {
 254                                         fclose(file);
 255                                         if (bloque != NULL) free(bloque);
 256                                         return -1;
 257                                 }
 258                         } else {
 259                                 if ( cant_bloques-1 == i )
 260                                         resto = emu->tam_reg - i*(emu->tam_bloque - sizeof(EMUFS_REG_ID));
 261                                 if ( emufs_fsc_agregar(emu, num_bloque+i, fs-resto) !=0 ){
 262                                         fclose(file);
 263                                         if (bloque != NULL) free(bloque);
 264                                         return -1;
 265                                 }
 266                         }
 267                         if ( i == 0 ){
 268                                 if ( emufs_idx_agregar(emu, ID_aux, num_bloque) != 0 ){
 269                                         if (bloque != NULL) free(bloque);
 270                                         return -1;
 271                                 }
 272                         }
 273                 }
 274         }
 275         free(bloque);
 276         return ID_aux;
 277 }
 278
 279 /*Graba un bloque en el archivo*/
 280 int emufs_tipo3_grabar_bloque(EMUFS *emu, void *ptr, EMUFS_BLOCK_ID num)
 281 {
 282         FILE* file;
 283         char name_f[255];
 284
 285         strcpy(name_f,emu->nombre);
 286         strcat(name_f,".dat");
 287
 288         if ( (file = fopen(name_f,"r+"))==NULL ) return -1; /*ERROR*/
 289         /* Salto el header del archivo */
 290         fseek(file, sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE), SEEK_SET);
 291         fseek(file, num*emu->tam_bloque, SEEK_CUR);
 292         fwrite(ptr, emu->tam_bloque, 1, file);
 293
 294         fclose(file);
 295         return 0;
 296 }
 297
 298 /*borra un registro de un bloque y acomoda los registros que quedan*/
 299 int emufs_tipo3_borrar_registro(EMUFS *emu, EMUFS_REG_ID ID)
 300 {
 301         EMUFS_BLOCK_SIZE num_bloque;
 302         EMUFS_BLOCK_SIZE ptr_elim;
 303         EMUFS_BLOCK_SIZE ptr_mov;
 304         EMUFS_REG_ID ID_aux;
 305         EMUFS_FREE fs;
 306         char *bloque;
 307         int err = 0, i;
 308
 309         num_bloque = emufs_idx_buscar_registro(emu, ID);
 310         if (!(bloque = emufs_tipo3_leer_bloque(emu, num_bloque, &err))) {
 311                 /* TODO Manejo de errores */
 312                 PERR("no se pudo leer el bloque");
 313                 return -1;
 314         }
 315
 316         /*apunto al registro que voy a eliminar*/
 317         ptr_elim = 0;
 318         while ( ptr_elim < emu->tam_bloque ){
 319                 memcpy(&ID_aux, bloque+ptr_elim, sizeof(EMUFS_REG_ID));
 320                 if ( ID_aux == ID )
 321                         break;
 322                 ptr_elim += emu->tam_reg + sizeof(EMUFS_REG_ID);
 323         }
 324
 325         /*apunto al registro que voy a mover*/
 326         ptr_mov = ptr_elim + emu->tam_reg + sizeof(EMUFS_REG_ID);
 327
 328         while ( (ptr_mov+sizeof(EMUFS_REG_ID)+emu->tam_reg) < emu->tam_bloque ){
 329                 memcpy(bloque+ptr_elim, bloque+ptr_mov, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 330                 /* Blanqueo el area que movi */
 331                 memset(bloque+ptr_mov, 0, sizeof(EMUFS_REG_ID)+emu->tam_reg);
 332                 ptr_elim = ptr_mov;
 333                 ptr_mov += sizeof(EMUFS_REG_ID) + emu->tam_reg;
 334         }
 335
 336         /*grabo el bloque en el archivo*/
 337         if ( emu->tam_bloque < emu->tam_reg )
 338                 memset(bloque, 0, emu->tam_bloque);
 339         if ( emufs_tipo3_grabar_bloque(emu, bloque, num_bloque) == -1 ){
 340                 free(bloque);
 341                 PERR("No se pudo grabar el bloque");
 342                 return -1;
 343         }
 344
 345         /*actualizo archivo .fsc*/
 346         if ( emu->tam_bloque < emu->tam_reg ) {
 347                 for (i=0; i<emu->tam_reg/(emu->tam_bloque-sizeof(EMUFS_REG_ID))+1; i++)
 348                         if ( emufs_fsc_agregar(emu, num_bloque+i, emu->tam_bloque) != 0 ) return -1;
 349         } else {
 350                 fs = emufs_fsc_get_fs(emu, num_bloque);
 351                 if ( emufs_fsc_agregar(emu, num_bloque, fs + emu->tam_reg + sizeof(EMUFS_REG_ID)) != 0 ) return -1;
 352         }
 353         /*actualizo archivo .did*/
 354         if ( emufs_did_agregar(emu, ID) != 0 ) return -1;
 355
 356         /*actualizo archivo .idx*/
 357         if ( emufs_idx_borrar(emu, ID) != 0 ) return -1;
 358
 359         free(bloque);
 360         return 0;
 361 }
 362
 363 EMUFS_Estadisticas emufs_tipo3_leer_estadisticas(EMUFS *emu)
 364 {
 365         FILE *f;
 366         EMUFS_Estadisticas stats;
 367         EMUFS_REG_ID *tmp;
 368         char name_f[255];
 369
 370         memset(&stats,0,sizeof(EMUFS_Estadisticas));
 371         strcpy(name_f,emu->nombre);
 372         strcat(name_f,".dat");
 373         if ( (f = fopen(name_f,"r")) == NULL){
 374                         PERR("No se pudo abrir el archivo");
 375                         return stats;
 376         }
 377
 378         fseek(f,0,SEEK_END);
 379         stats.tam_archivo_bytes = ftell(f);
 380         stats.cant_bloques =(stats.tam_archivo_bytes-sizeof(EMUFS_Tipo)-sizeof(EMUFS_BLOCK_SIZE)-sizeof(EMUFS_REG_SIZE))/
 381                                                  emu->tam_bloque;
 382         tmp = emufs_idx_get(emu, &stats.tam_archivo);
 383         if (tmp) free(tmp);
 384                 stats.info_control=stats.tam_archivo*sizeof(EMUFS_REG_ID)+sizeof(EMUFS_Tipo)+
 385                                                 sizeof(EMUFS_BLOCK_SIZE)+sizeof(EMUFS_REG_SIZE);
 386         /* Obtengo las stats de FSC */
 387         stats.total_fs = emufs_fsc_get_total_fs(emu);
 388         stats.media_fs = emufs_fsc_get_media_fs(emu);
 389         emufs_fsc_get_max_min_fs(emu,&stats.min_fs,&stats.max_fs);
 390
 391         fclose(f);
 392         return stats;
 393 }
 394
 395 EMUFS_REG_ID emufs_tipo3_modificar_registro(EMUFS *emu, EMUFS_REG_ID id, void *data, EMUFS_REG_SIZE size, int *error)
 396 {
 397         emufs_tipo3_borrar_registro(emu, id);
 398         return emufs_tipo3_grabar_registro(emu, data, size, error);
 399 }
 400
 401 void* emufs_tipo3_leer_registro_raw(EMUFS *emu, EMUFS_REG_ID ID, EMUFS_REG_SIZE *size, int *pos)
 402 {
 403         char* bloque, *tmp, *cur;
 404         EMUFS_BLOCK_ID block;
 405         EMUFS_REG_ID ID_aux;
 406         EMUFS_BLOCK_SIZE iterador = 0;
 407         int err, cant_bloques, i;
 408
 409         bloque = NULL;
 410         if (emu->tam_reg < emu->tam_bloque) {
 411                 /* Aca estoy en el caso de que 1 registro entra en 1 solo bloque */
 412                 block = emufs_idx_buscar_registro(emu,ID);
 413                 if ( block == EMUFS_NOT_FOUND ) {
 414                         return NULL;
 415                 }
 416                 if ((bloque = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 417                         return NULL;
 418                 }
 419
 420                 ID_aux = -1;
 421                 iterador = 0;
 422
 423                 /* Busco el offset desde el comienzo desde donde arranca el registro
 424                  * buscado, para luego resaltarlo en al GUI
 425                  */
 426                 while ( iterador < emu->tam_bloque ) {
 427                         memcpy(&ID_aux, bloque+iterador, sizeof(EMUFS_REG_ID));
 428                         if ( ID_aux == ID ){
 429                                 *pos = iterador;
 430                                 *size = emu->tam_bloque;
 431                                 break;
 432                         }
 433                         iterador += sizeof(EMUFS_REG_ID);
 434                         iterador += emu->tam_reg;
 435                 }
 436         } else {
 437                 /* Junto todos los bloques que ocupa el registro y agrego un separador de bloques */
 438
 439                 /* Busco el primer bloque */
 440                 block = emufs_idx_buscar_registro(emu,ID);
 441                 if ( block == EMUFS_NOT_FOUND ){
 442                         return NULL;
 443                 }
 444                 cant_bloques = emu->tam_reg / (emu->tam_bloque - sizeof(EMUFS_REG_ID))+1;
 445                 *size = emu->tam_bloque*cant_bloques /*+ cant_bloques*2*/ - sizeof(EMUFS_REG_ID)*(cant_bloques-1);
 446                 bloque = (char *)malloc(*size);
 447                 cur = bloque;
 448                 *pos = 0;
 449
 450                 /* El bloque 0 va completo */
 451                 err = 0;
 452                 if ((tmp = emufs_tipo3_leer_bloque(emu, block, &err)) == NULL) {
 453                         /* Oops! ... un bloque no existe, todo mal! */
 454                         free(bloque);
 455                         return NULL;
 456                 }
 457                 memcpy(cur, tmp, emu->tam_bloque);
 458                 cur += emu->tam_bloque;
 459 /*              memcpy(cur, "<>", 2);
 460                 cur += 2;*/
 461                 free(tmp);
 462
 463                 /* En resto de los bloques no pongo el ID porque ya esta en el primero */
 464                 for(i=1; i<cant_bloques; i++) {
 465                         err = 0;
 466                         if ((tmp = emufs_tipo3_leer_bloque(emu, block+i, &err)) == NULL) {
 467                                 /* Oops! ... un bloque no existe, todo mal! */
 468                                 free(bloque);
 469                                 return NULL;
 470                         }
 471                         memcpy(cur, tmp+sizeof(EMUFS_REG_ID), emu->tam_bloque-sizeof(EMUFS_REG_ID));
 472                         cur += emu->tam_bloque - sizeof(EMUFS_REG_ID);
 473 /*                      memcpy(cur, "<>", 2);
 474                         cur += 2;*/
 475                         free(tmp);
 476                 }
 477                 (*cur) = '\0';
 478         }
 479         return bloque;
 480 }
 481
 482 void emufs_tipo3_compactar(EMUFS *emu)
 483 {
 484         EMUFS_REG_ID *tmp, max_id;
 485         EMUFS_BLOCK_ID block_id;
 486         EMUFS_REG_SIZE size;
 487         EMUFS_FREE fs;
 488         char name[255];
 489         char *reg;
 490         int err=0, ID_aux, i;
 491
 492         strcpy(name, emu->nombre);
 493         strcat(name, ".dat");
 494
 495         /* si el bloque es mas chico que el registro no hace falta compactar */
 496         /*if( emu->tam_reg-sizeof(EMUFS_REG_ID) > emu->tam_bloque ) return;     */
 497
 498         tmp = emufs_idx_get(emu, &max_id);
 499         if (tmp) free(tmp);
 500         for( i=0; i<=max_id; i++){
 501                 /* si el id no existe paso al siguiente*/
 502                 if ( emufs_idx_existe_id(emu, i) != 0 ) continue;
 503                 reg = emufs_tipo3_leer_registro(emu, i, &size, &err);
 504                 if (err){
 505                         PERR("No se pudo leer el registro");
 506                         return;
 507                 }
 508                 emufs_tipo3_borrar_registro(emu, i);
 509                 ID_aux = emufs_tipo3_grabar_registro(emu, reg, emu->tam_reg, &err);
 510                 i++;
 511         }
 512         /*tengo que truncar el archivo*/
 513         /*bloques_vacios = emufs_fsc_get_cant_bloques_vacios(emu)-1;
 514         */
 515         block_id = emufs_fsc_buscar_lugar(emu, emu->tam_bloque, &fs);
 516         size = sizeof(EMUFS_Tipo)+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_BLOCK_SIZE)+block_id*emu->tam_bloque;
 517         if (truncate(name, size)!=0)
 518                 PERR("NO TRUNQUE NADA");
 519         /*hay que truncar el fsc!!!*/
 520         if(emu->tam_bloque<emu->tam_reg-sizeof(EMUFS_REG_ID)) block_id = block_id/2;
 521         if (emufs_fsc_truncate(emu, block_id)!= 0)
 522                 PERR("NO TURNQUE EL FSC");
 523         free(reg);
 524 }