rom/filesys/afs/validator.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /*
   7  * -date------ -name------------------- -description-----------------------------
   8  * 02-jan-2008 [Tomasz Wiszkowski]      created disk validation procedures
   9  * 03-jan-2008 [Tomasz Wiszkowski]      updated procedure to strip fake dircache blocks
  10  *                                      no directory cache handling present here.
  11  * 04-jan-2008 [Tomasz Wiszkowski]      corrected procedure to *ignore* data block sizes
  12  *                                      for OFS volumes since DOSTYPE does not differentiate them,
  13  *                                      corrected tabulation.
  14  * 07-jan-2008 [Tomasz Wiszkowski]      partitioned procedures to prepare non-recursive scan
  15  */
  16
  17 #include "validator.h"
  18 #include "volumes.h"
  19
  20 #undef SDEBUG
  21 #undef DEBUG
  22 #define DEBUG 0
  23
  24 #ifdef __AROS__
  25 #include <dos/dostags.h>
  26 #include <utility/tagitem.h>
  27 #include <exec/ports.h>
  28 #include <exec/types.h>
  29 #include "afsblocks.h"
  30 #include "cache.h"
  31 #include "error.h"
  32 #include <exec/ports.h>
  33 #include <exec/io.h>
  34 #include <dos/dos.h>
  35 #include <aros/debug.h>
  36 #include "misc.h"
  37 #include "extstrings.h"
  38 #endif
  39
  40 /*******************************************
  41  Name  : checkValid
  42  Descr : verify whether disk is validated and writable.
  43          since we need at least a stub function, it has to be
  44          declared outside __AROS__ scope
  45  Input : afsbase, volume
  46  Output: 0 for unvalidated disc, 1 otherwise
  47  Author: Tomasz Wiszkowski
  48 ********************************************/
  49 LONG checkValid(struct AFSBase *afs, struct Volume *vol)
  50 {
  51 #ifdef __AROS__
  52     struct BlockCache *blockbuffer;
  53     blockbuffer = getBlock(afs, vol, vol->rootblock);
  54     UBYTE  n[MAX_NAME_LENGTH];
  55     STRPTR name;
  56     name=(STRPTR)((char *)blockbuffer->buffer+(BLK_DISKNAME_START(vol)*4));
  57     StrCpyFromBstr(name, n);
  58         while (vol->state == ID_WRITE_PROTECTED
  59               && showError(afs, ERR_WRITEPROTECT, n));
  60
  61         if (vol->state == ID_VALIDATING)
  62         {
  63                 if (showError(afs, ERR_DISKNOTVALID))
  64                 {
  65                         if (vr_OK == launchValidator(afs, vol))
  66                                 return 1;
  67                 }
  68                 return 0;
  69         }
  70
  71         return vol->state == ID_VALIDATED ? 1 : 0;
  72 #else
  73         return 1;
  74 #endif
  75 }
  76
  77 /*******************************************
  78  Name  : launchValidator
  79  Descr : launch validation process for specified medium
  80          since we need at least a stub function, it has to be
  81          declared outside __AROS__ scope
  82  Input : volume
  83  Output: none
  84  Author: Tomasz Wiszkowski
  85 ********************************************/
  86 LONG launchValidator(struct AFSBase *afsbase, struct Volume *volume)
  87 {
  88 #ifdef __AROS__
  89         D(bug("[afs]: flushing cache...\n"));
  90         flushCache(afsbase, volume);
  91
  92         /*
  93          * initially this was meant to be a synchronous validation
  94          * but due to obvious problems with IO commands idea was eventually given up
  95          */
  96         return validate(afsbase, volume);
  97 #else
  98         return 0;
  99 #endif
 100 }
 101
 102
 103
 104
 105 /*****************************************
 106  * this set is good only for AROS NATIVE
 107  ****************************************/
 108 #ifdef __AROS__
 109
 110 LONG validate(struct AFSBase *afs, struct Volume *vol)
 111 {
 112         DiskStructure     ds;
 113         ValidationResult  res = vr_OK;
 114
 115         /*
 116          * fill in diskstructure. we will need it for the sake of validation.
 117          */
 118         ds.vol = vol;
 119         ds.afs = afs;
 120         ds.flags = 0;
 121
 122         /*
 123          * we could use some inhibiting here
 124          */
 125         if (0 == bm_allocate_bitmap(&ds))
 126         {
 127                 inhibit(afs, vol, 1);
 128                 res = start_superblock(&ds);
 129                 inhibit(afs, vol, 0);
 130         }
 131         bm_free_bitmap(&ds);
 132
 133         switch (res)
 134         {
 135                 case vr_OK:
 136                         D(bug("[afs validate]: Validation complete. \n"));
 137                         break;
 138                 case vr_NoAccess:
 139                         D(bug("[afs validate]: Could not create access point. \n"));
 140                         break;
 141                 case vr_ReadError:
 142                         D(bug("[afs validate]: Could not read disk. \n"));
 143                         break;
 144                 case vr_UnknownDiskType:
 145                         D(bug("[afs validate]: Unhandled disk type. \n"));
 146                         break;
 147                 case vr_InvalidChksum:
 148                         D(bug("[afs validate]: Invalid block checksum. \n"));
 149                         break;
 150                 case vr_StructureDamaged:
 151                         D(bug("[afs validate]: Structure damaged. \n"));
 152                         break;
 153                 case vr_OutOfMemory:
 154                         D(bug("[afs validate]: Could not allocate memory to complete operation. \n"));
 155                         break;
 156                 case vr_BlockUsedTwice:
 157                         D(bug("[afs validate]: Physical block used more than once. \n"));
 158                         break;
 159                 case vr_Aborted:
 160                         D(bug("[afs validate]: Aborted by user. \n"));
 161                         break;
 162                 case vr_BlockOutsideDisk:
 163                         D(bug("[afs validate]: Block outside volume boundaries. \n"));
 164                         break;
 165         }
 166
 167         {
 168                 struct BlockCache *bc = getBlock(afs, vol, vol->rootblock);
 169                 ULONG* mem = bc->buffer;
 170
 171                 if (res != vr_OK)
 172                 {
 173                         mem[BLK_BITMAP_VALID_FLAG(vol)] = 0;
 174                         vol->state = ID_VALIDATING;
 175                 }
 176                 else
 177                         vol->state = ID_VALIDATED;
 178
 179                 if (verify_checksum(&ds, mem) != 0)
 180                 {
 181                         D(bug("[afs validate]: block checksum does not match.\n"));
 182                         bc->flags |= BCF_WRITE;
 183                 }
 184         }
 185         /*
 186          * it's not neccessary here, but res is holding validation result
 187          * one may wish to open some requester at this point in the future
 188          */
 189         return res;
 190 }
 191
 192 /*
 193  * validate range
 194  */
 195 LONG check_block_range(DiskStructure *ds, ULONG num)
 196 {
 197         if ((num < ds->vol->bstartblock) || (num >= ds->vol->countblocks))
 198         {
 199                 D(bug("[afs validate]: Block located outside volume range. Condition %lu <= %lu < %lu not met.\n",
 200                         ds->vol->bstartblock,
 201                         num,
 202                         ds->vol->countblocks));
 203                 showError(ds->afs, ERR_BLOCK_OUTSIDE_RANGE, num);
 204                 return 0;
 205         }
 206         return 1;
 207 }
 208
 209 /*
 210  * begin
 211  */
 212 ValidationResult start_superblock(DiskStructure *ds)
 213 {
 214         ValidationResult res = vr_OK;
 215
 216         res = collect_directory_blocks(ds, ds->vol->rootblock);
 217         D(bug("[afs validate]: validation complete. Result: %ld\n", res));
 218
 219         /*
 220          * record bitmap back to disk, set bitmap valid flag, and update checksum of the root sector
 221          * please note: it is hell important to have this checksum valid ;) so you better keep an eye
 222          * on all your changes
 223          */
 224         if (res == vr_OK)
 225         {
 226                 record_bitmap(ds);
 227         }
 228
 229         return res;
 230 }
 231
 232 /*
 233  * verify_checksum
 234  */
 235 ULONG verify_checksum(DiskStructure *ds, ULONG *block)
 236 {
 237         ULONG sum = 0;
 238         LONG i;
 239
 240         D(bug("[afs validate]: verifying block checksum... "));
 241
 242         for (i=0; i<ds->vol->SizeBlock; i++)
 243         {
 244                 sum += OS_BE2LONG(block[i]);
 245         }
 246
 247         if (sum != 0)
 248         {
 249                 D(bug("checksum invalid!\n"));
 250                 sum -= OS_BE2LONG(block[BLK_CHECKSUM]);
 251                 D(bug("[afs validate]: current sum: %08lx, valid sum: %08lx. correcting\n", block[BLK_CHECKSUM], sum));
 252                 block[BLK_CHECKSUM] = OS_LONG2BE(-sum);
 253                 return -sum;
 254         }
 255
 256         D(bug("checksum valid!\n"));
 257         return 0;
 258 }
 259
 260 /*
 261  * verify_bm_checksum
 262  */
 263 ULONG verify_bm_checksum(DiskStructure *ds, ULONG *block)
 264 {
 265         ULONG sum = 0;
 266         ULONG i;
 267
 268         D(bug("[afs validate]: verifying bitmap checksum... "));
 269
 270         for (i=0; i<ds->vol->SizeBlock; i++)
 271         {
 272                 sum += OS_BE2LONG(block[i]);
 273         }
 274
 275         if (sum != 0)
 276         {
 277                 D(bug("checksum invalid!\n"));
 278                 sum -= OS_BE2LONG(block[0]);
 279                 D(bug("[afs validate]: current sum: %08lx, valid sum: %08lx. correcting\n", block[0], sum));
 280                 block[0] = OS_LONG2BE(-sum);
 281                 return -sum;
 282         }
 283
 284         D(bug("checksum valid!\n"));
 285         return 0;
 286 }
 287
 288 /*
 289  * check single block - this procedure should do as much as possible
 290  */
 291 ValidationResult check_block(DiskStructure* ds, struct BlockCache* block)
 292 {
 293         ULONG* mem;
 294         ULONG id;
 295
 296         /*
 297          * first check cache validity
 298          */
 299         if (0 == block)
 300         {
 301                 D(bug("[afs validate] Error: no block passed.\n"));
 302                 return vr_ReadError;
 303         }
 304
 305         if (0 == block->blocknum)
 306         {
 307                 D(bug("[afs validate] Block could not be read.\n"));
 308                 return vr_ReadError;
 309         }
 310
 311         mem = block->buffer;
 312
 313         /*
 314          * check types first: we expect block of T_SHORT (2) or T_LIST (16) type
 315          */
 316         id = OS_BE2LONG(mem[BLK_PRIMARY_TYPE]);
 317         if ((id != T_SHORT) &&
 318                  (id != T_LIST))
 319         {
 320                 D(bug("[afs validate]: block is not of known-type (%08lx). asking whether to correct\n", id));
 321
 322                 if (block->blocknum == ds->vol->rootblock)
 323                 {
 324                         if ((0 == (ds->flags & ValFlg_DisableReq_MaybeNotAFS)) && (0 == showError(ds->afs, ERR_POSSIBLY_NOT_AFS)))
 325                                 return vr_Aborted;
 326                         ds->flags |= ValFlg_DisableReq_MaybeNotAFS;
 327                         D(bug("[afs validate]: will continue per user decision. faulty block will be removed from structure.\n"));
 328                 }
 329                 return vr_StructureDamaged;
 330         }
 331
 332         /*
 333          * set bitmap block (mark as used)
 334          */
 335         if (bm_mark_block(ds, block->blocknum))
 336         {
 337                 D(bug("[afs validate]: block %lu used twice! aborting!\n", block->blocknum));
 338                 return vr_BlockUsedTwice;
 339         }
 340
 341         return vr_OK;
 342 }
 343
 344 ValidationResult collect_bitmap(DiskStructure* ds, struct BlockCache* block)
 345 {
 346         ULONG strt=BLK_BITMAP_POINTERS_START(ds->vol),
 347                         stop=BLK_BITMAP_POINTERS_END(ds->vol),
 348                         ext =BLK_BITMAP_EXTENSION(ds->vol),
 349                         i, blk;
 350
 351         ULONG* mem = block->buffer;
 352
 353         do
 354         {
 355                 for (i=strt; i<=stop; ++i)
 356                 {
 357                         blk = OS_BE2LONG(mem[i]);
 358                         if (blk == 0)
 359                                 continue;
 360
 361                         /*
 362                          * verify whether bitmap block resides on disk
 363                          * if the range validation fails, simply do not add the block to the list
 364                          *
 365                          * unfortunately bitmap block reallocation has not been implemented
 366                          * since this is the most unlikely happening issue
 367                          */
 368                         if (0 == check_block_range(ds, blk))
 369                                 return vr_BlockOutsideDisk;
 370
 371                         /*
 372                          * mark block as used.
 373                          * the bitmap blocks *could be reallocated* (and in fact should be)
 374                          * if the bm_mark_block returns something else than st_OK (that is,
 375                          * in case, when block is out of range, or simply used twice).
 376                          *
 377                          * i'm sorry, but this has not been introduced yet.
 378                          */
 379                         if (bm_mark_block(ds, blk) != st_OK)
 380                         {
 381                                 showError(ds->afs, ERR_BLOCK_USED_TWICE, blk);
 382                                 return vr_BlockUsedTwice;
 383                         }
 384
 385                         /*
 386                          * add bitmap block to bitmap block set
 387                          */
 388                         bm_add_bitmap_block(ds, blk);
 389                 }
 390
 391                 /*
 392                  * collect bitmap extension blocks
 393                  */
 394                 if ((blk = OS_BE2LONG(mem[ext])) != 0)
 395                 {
 396                         D(bug("[afs validate] Following to next bitmap extension block at %08lx\n", blk));
 397                         if (0 == check_block_range(ds, blk))
 398                                 return vr_BlockOutsideDisk;
 399
 400                         if (bm_mark_block(ds, blk) != st_OK)
 401                                 return vr_BlockUsedTwice;
 402
 403                         block = getBlock(ds->afs, ds->vol, blk);
 404                         mem = block->buffer;
 405                         strt = 0;
 406                         stop = ds->vol->SizeBlock-2;
 407                         ext  = ds->vol->SizeBlock-1;
 408                 }
 409         }
 410         while (blk != 0);
 411
 412         return vr_OK;
 413 }
 414
 415 ValidationResult collect_file_extensions(DiskStructure* ds, struct BlockCache* block)
 416 {
 417         ULONG i, blk, clr=0;
 418         ULONG* mem = block->buffer;
 419
 420         ds->file_blocks = 0;
 421
 422         do
 423         {
 424                 for (i=BLK_TABLE_END(ds->vol); i>=BLK_TABLE_START; --i)
 425                 {
 426                         if (clr != 0)
 427                         {
 428                                 mem[i] = 0;
 429                                 block->flags |= BCF_WRITE;
 430                                 continue;
 431                         }
 432
 433                         blk = OS_BE2LONG(mem[i]);
 434
 435                         /*
 436                          * if this was the last data block, purge rest
 437                          */
 438                         if (blk == 0)
 439                         {
 440                                 clr = 1;
 441                                 continue;
 442                         }
 443
 444
 445                         /*
 446                          * verify if block still belongs to this disk, purge if it doesn't
 447                          */
 448                         if (0 == check_block_range(ds, blk))
 449                         {
 450                                 D(bug("[afs validate] file data block outside range. truncating\n"));
 451                                 block->flags |= BCF_WRITE;
 452                                 clr = 1;
 453                                 mem[i] = 0;
 454                                 continue;
 455                         }
 456
 457                         /*
 458                          * mark block as used.
 459                          */
 460                         if (bm_mark_block(ds, blk) != st_OK)
 461                         {
 462                                 D(bug("[afs validate] file data block used twice. truncating\n"));
 463                                 block->flags |= BCF_WRITE;
 464                                 clr = 1;
 465                                 mem[i] = 0;
 466                                 continue;
 467                         }
 468
 469                         ++ds->file_blocks;
 470                 }
 471
 472                 /*
 473                  * if block is marked as 'write', make sure it holds correct sum.
 474                  */
 475                 if (block->flags & BCF_WRITE)
 476                         verify_checksum(ds, block->buffer);
 477                 /*
 478                  * collect bitmap extension blocks
 479                  */
 480                 if ((blk = OS_BE2LONG(mem[BLK_EXTENSION(ds->vol)])) != 0)
 481                 {
 482                         D(bug("[afs validate] Following to next file extension block at %08lx\n", blk));
 483                         if (0 == check_block_range(ds, blk))
 484                         {
 485                                 D(bug("[afs validate] Extension block outside range. truncating file\n"));
 486                                 mem[BLK_EXTENSION(ds->vol)] = 0;
 487                                 block->flags |= BCF_WRITE;
 488                                 blk = 0;
 489                         }
 490                         else if (bm_mark_block(ds, blk) != st_OK)
 491                         {
 492                                 D(bug("[afs validate] Bitmap block already marked as used. truncating file\n"));
 493                                 mem[BLK_EXTENSION(ds->vol)] = 0;
 494                                 block->flags |= BCF_WRITE;
 495                                 blk = 0;
 496                         }
 497                         else
 498                         {
 499                                 block = getBlock(ds->afs, ds->vol, blk);
 500                                 mem = block->buffer;
 501                         }
 502                 }
 503
 504                 /*
 505                  * update sum; if changed, mark block for writing
 506                  */
 507                 if (0 != verify_checksum(ds, block->buffer))
 508                         block->flags |= BCF_WRITE;
 509         }
 510         while (blk != 0);
 511
 512         return vr_OK;
 513 }
 514
 515 /*
 516  * collect directories
 517  */
 518 ValidationResult collect_directory_blocks(DiskStructure *ds, ULONG blk)
 519 {
 520         struct BlockCache *bc;
 521         LONG entry_type;
 522         LONG primary_type;
 523         ULONG id;
 524
 525         D(bug("[afs validate]: analyzing block %lu\n", blk));
 526
 527         /*
 528          * check range. Note that the whole process here is not 'reversible':
 529          * if you mark bitmap blocks as used, and then just return in the middle,
 530          * it won't get freed automagically, so mark it only when you know it should be there.
 531          */
 532         if (0 == check_block_range(ds, blk))
 533                 return vr_BlockOutsideDisk;
 534
 535         /*
 536          * we don't set block usage flags: we will re-read the block anyways.
 537          */
 538         bc = getBlock(ds->afs, ds->vol, blk);
 539
 540         /*
 541          * initial block analysis
 542          */
 543         id = check_block(ds, bc);
 544         if (id != vr_OK)
 545                 return id;
 546
 547         /*
 548          * collect types
 549          */
 550         entry_type = OS_BE2LONG(bc->buffer[BLK_SECONDARY_TYPE(ds->vol)]);
 551         primary_type = OS_BE2LONG(bc->buffer[BLK_PRIMARY_TYPE]);
 552
 553         switch (primary_type) {
 554             case T_LIST:
 555                 break;
 556             case T_SHORT:
 557                 break;
 558             case T_DATA:
 559                 break;
 560             default:
 561                 /* TODO: handle unknown primary type */
 562                 break;
 563         }
 564
 565         /*
 566          * for root block: collect all bitmap blocks now
 567          */
 568
 569         /*
 570          * i won't hide it: there's plenty of things to check here, but
 571          * since it's just a validation task
 572          * i have decided to remove the redundant code.
 573          */
 574
 575         /*
 576          * ok, if anyone wants to remove the bitmap allocations and re-allocate them by himself
 577          * here's the good place to start doing it. myself, i think the best way is to rely on
 578          * operating system in this matter: unless someone damaged the disk structure, it's
 579          * perfectly safe to assume that number of allocated bitmap blocks is just enough for us
 580          * to store the bitmap. Again, it's not a salvaging, repairing NOR reorganizing task.
 581          */
 582
 583         /*
 584          * oh, btw; we also want to collect the bitmap blocks here so we know where to save new bitmap.
 585          */
 586         if (entry_type == 1)
 587         {
 588                 D(bug("[afs validate]: Checking and collecting bitmap blocks\n"));
 589
 590                 id = collect_bitmap(ds, bc);
 591                 if (id != vr_OK)
 592                         return id;
 593
 594                 /*
 595                  * initially -- mark bitmap status as valid
 596                  */
 597                 bc = getBlock(ds->afs, ds->vol, blk);
 598                 bc->buffer[BLK_BITMAP_VALID_FLAG(ds->vol)] = ~0;
 599                 verify_checksum(ds, bc->buffer);
 600                 bc->flags |= BCF_WRITE;
 601         }
 602
 603         /*
 604          * this is the collection procedure
 605          * we check for directories/files here only. if an entry is not a directory,
 606          * check if it is a file and accumulate data blocks for it.
 607          * here we are interested only in FOUR of SEVEN types: ROOT, DIRECTORY, FILE and FILE EXTENSION
 608          */
 609         if ((entry_type == 1) || (entry_type == 2))      // 1 = root, which is handled already, 3 = symlink, which we don't need, 4 = hardlink, which we don't want
 610         {
 611                 LONG i;
 612
 613                 /*
 614                  * clear directory cache block.
 615                  * fancy thing about directory cache: it is the best way to run into inconsistencies between file trees.
 616                  * two trees, one kept for compatibility (which is not kept btw as dostype is different), and the other
 617                  * for 'faster directory listing', but not always in sync
 618                  */
 619                 if (bc->buffer[BLK_EXTENSION(ds->vol)] != 0)
 620                 {
 621                         D(bug("[afs validate]: clearing dircache pointer\n"));
 622                         bc->buffer[BLK_EXTENSION(ds->vol)] = 0;
 623                         verify_checksum(ds, bc->buffer);
 624                         bc->flags |= BCF_WRITE;
 625                 }
 626
 627                 for (i=BLK_TABLE_START; i<=BLK_TABLE_END(ds->vol); i++)
 628                 {
 629                         id = OS_BE2LONG(bc->buffer[i]);
 630                         if (id != 0)
 631                         {
 632                                 /*
 633                                  * proceed with block collection. unless user decides to stop validation
 634                                  * move on and bug them about whatever is really bad
 635                                  */
 636                                 id = collect_directory_blocks(ds, id);
 637                                 if (id == vr_Aborted)
 638                                         return id;
 639
 640                                 /*
 641                                  * restore current block
 642                                  * this will work well if the modified block gets marked as BCF_WRITE
 643                                  */
 644                                 bc = getBlock(ds->afs, ds->vol, blk);
 645
 646                                 if (vr_OK != id)
 647                                 {
 648                                         /* it's a good idea to flag this requester, so it shows only once */
 649                                         if ((0 == (ds->flags & ValFlg_DisableReq_DataLossImminent)) && (0 == showError(ds->afs, ERR_DATA_LOSS_POSSIBLE)))
 650                                                 return vr_Aborted;
 651
 652                                         ds->flags |= ValFlg_DisableReq_DataLossImminent;
 653                                         bc->buffer[i] = 0;
 654                                         verify_checksum(ds, bc->buffer);
 655                                         bc->flags |= BCF_WRITE;
 656                                 }
 657                         }
 658                 }
 659         }
 660
 661         /*
 662          * collect file data blocks.
 663          * some files are too large to fit in a single list of data blocks
 664          * this covers scanning more blocks
 665          *
 666          * crap, i don't know if i should use entry_type=0 here, too :|
 667          */
 668         if (entry_type == -3)
 669         {
 670                 collect_file_extensions(ds, bc);
 671                 bc = getBlock(ds->afs, ds->vol, blk);
 672                 id = OS_BE2LONG(bc->buffer[BLK_BYTE_SIZE(ds->vol)]);
 673                 if (id > (ds->file_blocks * ds->vol->SizeBlock << 2))
 674                 {
 675                         bc->buffer[BLK_BYTE_SIZE(ds->vol)] = OS_LONG2BE(ds->file_blocks * ds->vol->SizeBlock << 2);
 676                         verify_checksum(ds, bc->buffer);
 677                         bc->flags |= BCF_WRITE;
 678                 }
 679         }
 680
 681         /*
 682          * finally, move on to next file in this hash chain. IF next file suffers anything, remove it and following files from hash chain.
 683          */
 684         id = OS_BE2LONG(bc->buffer[BLK_HASHCHAIN(ds->vol)]);
 685         if (id != 0)
 686         {
 687                 D(bug("[afs validate]: collecting other items in this chain\n"));
 688
 689                 /*
 690                  * collect other elements
 691                  */
 692                 id = collect_directory_blocks(ds, id);
 693
 694                 /*
 695                  * if aborted, simply quit
 696                  */
 697                 if (id == vr_Aborted)
 698                 {
 699                         return id;
 700                 }
 701
 702                 /*
 703                  * otherwise alter structure
 704                  */
 705                 if (id != 0)
 706                 {
 707                         D(bug("[afs validate]: removing faulty chain\n"));
 708                         bc = getBlock(ds->afs, ds->vol, blk);
 709                         bc->buffer[BLK_HASHCHAIN(ds->vol)] = 0;
 710                         verify_checksum(ds, bc->buffer);
 711                         bc->flags |= BCF_WRITE;
 712                 }
 713         }
 714
 715         return vr_OK;
 716 }
 717
 718 /*
 719  * record bitmap: stores bitmap in RAM (if you redefine a little) and saves it to disk.
 720  */
 721 void record_bitmap(DiskStructure *ds)
 722 {
 723         struct BlockCache *bc;
 724         ULONG *mem;
 725         ULONG i;
 726
 727         for (i=0; i<ds->bm_lastblk; i++)
 728         {
 729                 bc = getBlock(ds->afs, ds->vol, ds->bm_blocks[i]);
 730                 mem = bc->buffer;
 731
 732                 CopyMemQuick(&((char*)ds->bitmap)[i*((ds->vol->SizeBlock-1)<<2)], &mem[1], (ds->vol->SizeBlock-1)<<2);
 733                 verify_bm_checksum(ds, mem);
 734                 bc->flags |= BCF_WRITE;
 735         }
 736 }
 737
 738 /*
 739  * allocates enough store for the complete bitmap
 740  */
 741 LONG bm_allocate_bitmap(DiskStructure *ds)
 742 {
 743         ULONG i;
 744         ULONG bmap_blk_size;
 745
 746         /*
 747          * bitmap block size: blk_size - 4
 748          */
 749         bmap_blk_size = ((ds->vol->SizeBlock-1)<<2);
 750
 751         /*
 752          * total bitmap size is calculated as follows:
 753          * - total number of bits (rounded up to nearest multiple of 8) converted to bytes
 754          * - the above rounded up to nearest size of a single block - 4 bytes
 755          */
 756         i = (((ds->vol->countblocks + 7) >> 3) + (bmap_blk_size - 1)) / bmap_blk_size;
 757
 758         D(bug("[afs validate]: allocating bitmaps (%ld bytes)\n", i * bmap_blk_size));
 759         ds->bitmap = AllocVec(i * bmap_blk_size, MEMF_ANY);
 760
 761         D(bug("[afs validate]: allocating storage for bitmap blocks (%ld bytes)\n", i * sizeof(ULONG)));
 762         ds->bm_blocks   = (ULONG*)AllocVec(i * sizeof(ULONG), MEMF_ANY | MEMF_CLEAR);
 763
 764         D(bug("[afs validate]: allocating storage for bitmap extension blocks (%ld bytes) - way more than we really need\n", i * sizeof(ULONG)));
 765         ds->bme_blocks  = (ULONG*)AllocVec(i * sizeof(ULONG), MEMF_ANY | MEMF_CLEAR);
 766
 767         if ((ds->bitmap == 0) || (ds->bm_blocks == 0) || (ds->bme_blocks == 0))
 768         {
 769                 D(bug("[afs validate]: Unable to allocate memory for bitmap!\n"));
 770                 return -1;
 771         }
 772
 773         i *= bmap_blk_size;
 774
 775         while (i--)
 776         {
 777                 ((UBYTE*)ds->bitmap)[i] = ~0;
 778         }
 779
 780         ds->bm_lastblk  = 0;
 781         ds->bme_lastblk = 0;
 782
 783         return 0;
 784 }
 785
 786 void bm_free_bitmap(DiskStructure* ds)
 787 {
 788         D(bug("[afs validate]: freeing previously allocated bitmaps\n"));
 789         if (ds->bitmap != 0)
 790                 FreeVec(ds->bitmap);
 791         if (ds->bm_blocks != 0)
 792                 FreeVec(ds->bm_blocks);
 793         if (ds->bme_blocks != 0)
 794                 FreeVec(ds->bme_blocks);
 795 }
 796
 797 BitmapResult bm_mark_block(DiskStructure *ds, ULONG block)
 798 {
 799         if ((block < ds->vol->bstartblock) || (block >= ds->vol->countblocks))
 800         {
 801                 D(bug("block %ld is out of disk area range\n", block));
 802                 return st_OutOfRange;
 803         }
 804
 805         block -= ds->vol->bootblocks;
 806
 807 #if AROS_BIG_ENDIAN
 808         if ((((ULONG*)ds->bitmap)[block >> 5] & (1 << (block & 31))) == 0)
 809 #else
 810         if ((((ULONG*)ds->bitmap)[block >> 5] & (1 << ((block & 31)^24))) == 0)
 811 #endif
 812         {
 813                 D(bug("Duplicate block allocation for block %ld! Overlapping files?\n", (block+ds->vol->bstartblock)));
 814                 return st_AlreadyInUse;
 815         }
 816
 817 #if AROS_BIG_ENDIAN
 818         ((ULONG*)ds->bitmap)[block >> 5] &= ~(1 << (block & 31));
 819 #else
 820         ((ULONG*)ds->bitmap)[block >> 5] &= ~(1 << ((block & 31)^24));
 821 #endif
 822
 823         return st_OK;
 824 }
 825
 826 void bm_add_bitmap_block(DiskStructure *ds, ULONG blk)
 827 {
 828         ds->bm_blocks[ds->bm_lastblk] = blk;
 829         ds->bm_lastblk++;
 830 }
 831
 832 void bm_add_bitmap_extension_block(DiskStructure *ds, ULONG blk)
 833 {
 834         ds->bme_blocks[ds->bme_lastblk] = blk;
 835         ds->bme_lastblk++;
 836 }
 837
 838
 839 #endif
 840 /* vim: set noet:fdm=marker:fmr={,} :*/