tools/adflib/adf_bitm.c

   1 /*
   2  *  ADF Library. (C) 1997-1999 Laurent Clevy
   3  *
   4  *  adf_bitm.c
   5  *
   6  *  bitmap code
   7  */
   8
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12
  13 #include"adf_raw.h"
  14 #include"adf_bitm.h"
  15 #include"adf_err.h"
  16 #include"adf_disk.h"
  17 #include"adf_util.h"
  18 #include"defendian.h"
  19
  20 extern struct Env adfEnv;
  21
  22 /*
  23  * adfUpdateBitmap
  24  *
  25  */
  26 RETCODE adfUpdateBitmap(struct Volume *vol)
  27 {
  28     int i;
  29     struct bRootBlock root;
  30
  31 /*printf("adfUpdateBitmap\n");*/
  32
  33     if (adfReadRootBlock(vol, vol->rootBlock,&root)!=RC_OK)
  34         return RC_ERROR;
  35
  36     root.bmFlag = BM_INVALID;
  37     if (adfWriteRootBlock(vol,vol->rootBlock,&root)!=RC_OK)
  38         return RC_ERROR;
  39
  40     for(i=0; i<vol->bitmapSize; i++)
  41     if (vol->bitmapBlocksChg[i]) {
  42         if (adfWriteBitmapBlock(vol, vol->bitmapBlocks[i], vol->bitmapTable[i])!=RC_OK)
  43             return RC_ERROR;
  44         vol->bitmapBlocksChg[i] = FALSE;
  45     }
  46
  47     root.bmFlag = BM_VALID;
  48     adfTime2AmigaTime(adfGiveCurrentTime(),&(root.days),&(root.mins),&(root.ticks));
  49     if (adfWriteRootBlock(vol,vol->rootBlock,&root)!=RC_OK)
  50         return RC_ERROR;
  51
  52     return RC_OK;
  53 }
  54
  55
  56 /*
  57  * adfCountFreeBlocks
  58  *
  59  */
  60 ULONG adfCountFreeBlocks(struct Volume* vol)
  61 {
  62     ULONG freeBlocks;
  63     int j;
  64
  65     freeBlocks = 0L;
  66     for(j=vol->reservedBlocks; j<vol->totalBlocks; j++)
  67         if ( adfIsBlockFree(vol,j) )
  68             freeBlocks++;
  69
  70     return freeBlocks;
  71 }
  72
  73
  74 /*
  75  * adfReadBitmap
  76  *
  77  */
  78 RETCODE adfReadBitmap(struct Volume* vol, struct bRootBlock* root)
  79 {
  80     ULONG nBlock;
  81     ULONG mapSize;
  82     SECTNUM nSect;
  83     ULONG j, i;
  84     struct bBitmapExtBlock bmExt;
  85
  86     nBlock = vol->totalBlocks - vol->reservedBlocks;
  87
  88     mapSize = nBlock / (127*32);
  89     if ( (nBlock%(127*32))!=0 )
  90         mapSize++;
  91     vol->bitmapSize = mapSize;
  92     vol->lastAlloc = vol->rootBlock;
  93
  94     vol->bitmapTable = (struct bBitmapBlock**) malloc(sizeof(struct bBitmapBlock*)*mapSize);
  95     if (!vol->bitmapTable) {
  96         (*adfEnv.eFct)("adfReadBitmap : malloc, vol->bitmapTable");
  97         return RC_MALLOC;
  98     }
  99     vol->bitmapBlocks = (SECTNUM*) malloc(sizeof(SECTNUM)*mapSize);
 100     if (!vol->bitmapBlocks) {
 101         free(vol->bitmapTable);
 102         (*adfEnv.eFct)("adfReadBitmap : malloc, vol->bitmapBlocks");
 103         return RC_MALLOC;
 104     }
 105     vol->bitmapBlocksChg = (BOOL*) malloc(sizeof(BOOL)*mapSize);
 106     if (!vol->bitmapBlocksChg) {
 107         free(vol->bitmapTable); free(vol->bitmapBlocks);
 108         (*adfEnv.eFct)("adfReadBitmap : malloc, vol->bitmapBlocks");
 109         return RC_MALLOC;
 110     }
 111     for(i=0; i<mapSize; i++) {
 112         vol->bitmapBlocksChg[i] = FALSE;
 113
 114         vol->bitmapTable[i] = (struct bBitmapBlock*)malloc(sizeof(struct bBitmapBlock));
 115         if (!vol->bitmapTable[i]) {
 116             free(vol->bitmapBlocksChg); free(vol->bitmapBlocks);
 117             for(j=0; j<i; j++)
 118                 free(vol->bitmapTable[j]);
 119             free(vol->bitmapTable);
 120             (*adfEnv.eFct)("adfReadBitmap : malloc, vol->bitmapBlocks");
 121             return RC_MALLOC;
 122         }
 123     }
 124
 125     j=0; i=0;
 126     /* bitmap pointers in rootblock : 0 <= i <BM_SIZE */
 127     while(i<BM_SIZE && root->bmPages[i]!=0) {
 128         vol->bitmapBlocks[j] = nSect = root->bmPages[i];
 129         if ( !isSectNumValid(vol,nSect) ) {
 130             (*adfEnv.wFct)("adfReadBitmap : sector out of range");
 131         }
 132
 133         if (adfReadBitmapBlock(vol, nSect, vol->bitmapTable[j])!=RC_OK) {
 134             adfFreeBitmap(vol);
 135             return RC_ERROR;
 136         }
 137         j++; i++;
 138     }
 139     nSect = root->bmExt;
 140     while(nSect!=0) {
 141         /* bitmap pointers in bitmapExtBlock, j <= mapSize */
 142         if (adfReadBitmapExtBlock(vol, nSect, &bmExt)!=RC_OK) {
 143             adfFreeBitmap(vol);
 144             return RC_ERROR;
 145         }
 146         i=0;
 147         while(i<127 && j<mapSize) {
 148             nSect = bmExt.bmPages[i];
 149             if ( !isSectNumValid(vol,nSect) )
 150                 (*adfEnv.wFct)("adfReadBitmap : sector out of range");
 151             vol->bitmapBlocks[j] = nSect;
 152
 153             if (adfReadBitmapBlock(vol, nSect, vol->bitmapTable[j])!=RC_OK) {
 154                 adfFreeBitmap(vol);
 155                 return RC_ERROR;
 156             }
 157             i++; j++;
 158         }
 159         nSect = bmExt.nextBlock;
 160     }
 161
 162     return RC_OK;
 163 }
 164
 165 static inline ULONG sectorToMapMask(struct Volume *vol, SECTNUM nSect, ULONG **map, int *pblock)
 166 {
 167     int sectOfMap;
 168     int block;
 169     int indexInMap;
 170
 171     nSect -= vol->reservedBlocks;
 172     sectOfMap = nSect & 0x1f;
 173     nSect /= 32;
 174
 175     block = nSect / 127;
 176     indexInMap = nSect % 127;
 177
 178     *map = &(vol->bitmapTable[ block ]->map[ indexInMap ]);
 179     if (pblock)
 180         *pblock = block;
 181
 182     return (1UL << (sectOfMap & 0x1f));
 183 }
 184
 185 /*
 186  * adfIsBlockFree
 187  *
 188  */
 189 BOOL adfIsBlockFree(struct Volume* vol, SECTNUM nSect)
 190 {
 191     ULONG mask, *map;
 192
 193     mask = sectorToMapMask(vol, nSect, &map, NULL);
 194
 195 // printf("C %08lx %c\n", (unsigned long)(vol->firstBlock + nSect) * 512, (*map & mask) ? '1' : '0');
 196
 197     return (*map & mask) ? 1 : 0;
 198 }
 199
 200
 201 /*
 202  * adfSetBlockFree OK
 203  *
 204  */
 205 void adfSetBlockFree(struct Volume* vol, SECTNUM nSect)
 206 {
 207     ULONG mask, *map;
 208     int block;
 209
 210     mask = sectorToMapMask(vol, nSect, &map, &block);
 211
 212     *map |= mask;
 213
 214     vol->bitmapBlocksChg[ block ] = TRUE;
 215
 216 // printf("F 0x%08lx\n", (unsigned long)(vol->firstBlock + nSect) * 512);
 217 }
 218
 219
 220 /*
 221  * adfSetBlockUsed
 222  *
 223  */
 224 void adfSetBlockUsed(struct Volume* vol, SECTNUM nSect)
 225 {
 226     ULONG mask, *map;
 227     int block;
 228
 229     mask = sectorToMapMask(vol, nSect, &map, &block);
 230
 231     *map &= ~mask;
 232
 233     vol->bitmapBlocksChg[ block ] = TRUE;
 234
 235 // printf("A 0x%08lx\n", (unsigned long)(vol->firstBlock + nSect) * 512);
 236 }
 237
 238
 239 /*
 240  * adfGet1FreeBlock
 241  *
 242  */
 243 SECTNUM adfGet1FreeBlock(struct Volume *vol) {
 244     SECTNUM block[1];
 245     if (!adfGetFreeBlocks(vol,1,block))
 246         return((SECTNUM)-1);
 247     else
 248         return(block[0]);
 249 }
 250
 251 /*
 252  * adfGetFreeBlocks
 253  *
 254  */
 255 BOOL adfGetFreeBlocks(struct Volume* vol, int nbSect, SECTNUM* sectList)
 256 {
 257     int i;
 258     ULONG block = vol->lastAlloc;
 259
 260     if (nbSect == 0)
 261         return TRUE;
 262
 263     i = 0;
 264     while( i<nbSect ) {
 265         if ( adfIsBlockFree(vol, block) ) {
 266             sectList[i] = block;
 267             i++;
 268         }
 269
 270         block++;
 271         if (block == vol->lastAlloc)
 272             return FALSE;
 273
 274         if (block == vol->totalBlocks)
 275             block = vol->reservedBlocks;
 276     }
 277
 278     for(i=0; i<nbSect; i++)
 279         adfSetBlockUsed( vol, sectList[i] );
 280
 281     vol->lastAlloc = sectList[i-1];
 282
 283     return TRUE;
 284 }
 285
 286
 287 /*
 288  * adfCreateBitmap
 289  *
 290  * create bitmap structure in vol
 291  */
 292 RETCODE adfCreateBitmap(struct Volume *vol)
 293 {
 294     ULONG nBlock, mapSize ;
 295     int i, j;
 296
 297     nBlock = vol->totalBlocks - vol->reservedBlocks;
 298
 299     mapSize = nBlock / (127*32);
 300     if ( (nBlock%(127*32))!=0 )
 301         mapSize++;
 302     vol->bitmapSize = mapSize;
 303     vol->lastAlloc = vol->rootBlock;
 304
 305     vol->bitmapTable = (struct bBitmapBlock**)malloc( sizeof(struct bBitmapBlock*)*mapSize );
 306     if (!vol->bitmapTable) {
 307         (*adfEnv.eFct)("adfCreateBitmap : malloc, vol->bitmapTable");
 308         return RC_MALLOC;
 309     }
 310
 311     vol->bitmapBlocksChg = (BOOL*) malloc(sizeof(BOOL)*mapSize);
 312     if (!vol->bitmapBlocksChg) {
 313         free(vol->bitmapTable);
 314         (*adfEnv.eFct)("adfCreateBitmap : malloc, vol->bitmapBlocksChg");
 315         return RC_MALLOC;
 316     }
 317
 318     vol->bitmapBlocks = (SECTNUM*) malloc(sizeof(SECTNUM)*mapSize);
 319     if (!vol->bitmapBlocks) {
 320         free(vol->bitmapTable); free(vol->bitmapBlocksChg);
 321         (*adfEnv.eFct)("adfCreateBitmap : malloc, vol->bitmapBlocks");
 322         return RC_MALLOC;
 323     }
 324
 325     for(i=0; i<mapSize; i++) {
 326         vol->bitmapTable[i] = (struct bBitmapBlock*)malloc(sizeof(struct bBitmapBlock));
 327         if (!vol->bitmapTable[i]) {
 328             free(vol->bitmapTable); free(vol->bitmapBlocksChg);
 329             for(j=0; j<i; j++)
 330                 free(vol->bitmapTable[j]);
 331             free(vol->bitmapTable);
 332             (*adfEnv.eFct)("adfCreateBitmap : malloc");
 333             return RC_MALLOC;
 334         }
 335     }
 336
 337     for(i=vol->reservedBlocks; i < nBlock; i++)
 338         adfSetBlockFree(vol, i);
 339
 340     adfSetBlockUsed(vol, vol->rootBlock);
 341
 342     return RC_OK;
 343 }
 344
 345
 346 /*
 347  * adfWriteNewBitmap
 348  *
 349  * write ext blocks and bitmap
 350  *
 351  * uses vol->bitmapSize,
 352  */
 353 RETCODE adfWriteNewBitmap(struct Volume *vol)
 354 {
 355     struct bBitmapExtBlock bitme;
 356     SECTNUM *bitExtBlock;
 357     int n, i, k;
 358     int nExtBlock;
 359     int nBlock;
 360     SECTNUM *sectList;
 361     struct bRootBlock root;
 362
 363     sectList=(SECTNUM*)malloc(sizeof(SECTNUM)*vol->bitmapSize);
 364     if (!sectList) {
 365         (*adfEnv.eFct)("adfCreateBitmap : sectList");
 366         return RC_MALLOC;
 367     }
 368
 369     /* Write out the in-root bitmap blocks */
 370     if (adfReadRootBlock(vol, vol->rootBlock, &root)!=RC_OK) {
 371         free(sectList);
 372         return RC_ERROR;
 373     }
 374
 375     n = min( vol->bitmapSize, BM_SIZE );
 376     if (!adfGetFreeBlocks(vol, n, &sectList[0])) {
 377         free(sectList);
 378         return RC_ERROR;
 379     }
 380
 381     for(i=0; i<n; i++) {
 382         root.bmPages[i] = vol->bitmapBlocks[i] = sectList[i];
 383     }
 384     nBlock = n;
 385
 386      /* for devices with more than 25*127 blocks == hards disks */
 387     if (vol->bitmapSize>BM_SIZE) {
 388         nExtBlock = ((vol->bitmapSize-BM_SIZE)+126)/127;
 389
 390         bitExtBlock=(SECTNUM*)malloc(sizeof(SECTNUM)*nExtBlock);
 391         if (!bitExtBlock) {
 392             free(sectList);
 393             adfEnv.eFct("adfWriteNewBitmap : malloc failed");
 394             return RC_MALLOC;
 395         }
 396
 397         if (!adfGetFreeBlocks(vol, nExtBlock, bitExtBlock)) {
 398            adfEnv.eFct("adfWriteNewBitmap : can't get free Ext blocks");
 399            free(sectList); free(bitExtBlock);
 400            return RC_MALLOC;
 401         }
 402
 403         if (!adfGetFreeBlocks(vol, vol->bitmapSize - n, &sectList[n])) {
 404             free(sectList); free(bitExtBlock);
 405             return RC_ERROR;
 406         }
 407
 408         k = 0;
 409         root.bmExt = bitExtBlock[ k ];
 410         while( nBlock<vol->bitmapSize ) {
 411             i=0;
 412             memset(&bitme, 0, sizeof(bitme));
 413             while( i<127 && nBlock<vol->bitmapSize ) {
 414                 bitme.bmPages[i] = vol->bitmapBlocks[nBlock] = sectList[nBlock];
 415                 i++;
 416                 nBlock++;
 417             }
 418             if ( k+1<nExtBlock )
 419                 bitme.nextBlock = bitExtBlock[ k+1 ];
 420             else
 421                 bitme.nextBlock = 0;
 422             if (adfWriteBitmapExtBlock(vol, bitExtBlock[ k ], &bitme)!=RC_OK) {
 423                 free(sectList); free(bitExtBlock);
 424                 return RC_ERROR;
 425             }
 426             k++;
 427         }
 428         free( bitExtBlock );
 429
 430     }
 431     free( sectList);
 432
 433     if (adfWriteRootBlock(vol,vol->rootBlock,&root)!=RC_OK)
 434         return RC_ERROR;
 435
 436     return RC_OK;
 437 }
 438
 439 /*
 440  * adfReadBitmapBlock
 441  *
 442  * ENDIAN DEPENDENT
 443  */
 444 RETCODE
 445 adfReadBitmapBlock(struct Volume* vol, SECTNUM nSect, struct bBitmapBlock* bitm)
 446 {
 447     unsigned char buf[LOGICAL_BLOCK_SIZE];
 448
 449 //printf("bitmap %ld\n",nSect);
 450     if (adfReadBlock(vol, nSect, buf)!=RC_OK)
 451         return RC_ERROR;
 452
 453     memcpy(bitm, buf, LOGICAL_BLOCK_SIZE);
 454 #ifdef LITT_ENDIAN
 455     /* big to little = 68000 to x86 */
 456     swapEndian((unsigned char*)bitm, SWBL_BITMAP);
 457 #endif
 458
 459     if (bitm->checkSum!=adfNormalSum(buf,0,LOGICAL_BLOCK_SIZE))
 460         (*adfEnv.wFct)("adfReadBitmapBlock : invalid checksum");
 461
 462     return RC_OK;
 463 }
 464
 465
 466 /*
 467  * adfWriteBitmapBlock
 468  *
 469  * OK
 470  */
 471 RETCODE
 472 adfWriteBitmapBlock(struct Volume* vol, SECTNUM nSect, struct bBitmapBlock* bitm)
 473 {
 474     unsigned char buf[LOGICAL_BLOCK_SIZE];
 475     ULONG newSum;
 476
 477     memcpy(buf,bitm,LOGICAL_BLOCK_SIZE);
 478 #ifdef LITT_ENDIAN
 479     /* little to big */
 480     swapEndian(buf, SWBL_BITMAP);
 481 #endif
 482
 483     newSum = adfNormalSum(buf, 0, LOGICAL_BLOCK_SIZE);
 484     swLong(buf,newSum);
 485
 486 /*  dumpBlock((unsigned char*)buf);*/
 487     if (adfWriteBlock(vol, nSect, (unsigned char*)buf)!=RC_OK)
 488         return RC_ERROR;
 489
 490     return RC_OK;
 491 }
 492
 493
 494 /*
 495  * adfReadBitmapExtBlock
 496  *
 497  * ENDIAN DEPENDENT
 498  */
 499 RETCODE
 500 adfReadBitmapExtBlock(struct Volume* vol, SECTNUM nSect, struct bBitmapExtBlock* bitme)
 501 {
 502     unsigned char buf[LOGICAL_BLOCK_SIZE];
 503
 504     if (adfReadBlock(vol, nSect, buf)!=RC_OK)
 505         return RC_ERROR;
 506
 507     memcpy(bitme, buf, LOGICAL_BLOCK_SIZE);
 508 #ifdef LITT_ENDIAN
 509     swapEndian((unsigned char*)bitme, SWBL_BITMAP);
 510 #endif
 511
 512     return RC_OK;
 513 }
 514
 515
 516 /*
 517  * adfWriteBitmapExtBlock
 518  *
 519  */
 520 RETCODE
 521 adfWriteBitmapExtBlock(struct Volume* vol, SECTNUM nSect, struct bBitmapExtBlock* bitme)
 522 {
 523     unsigned char buf[LOGICAL_BLOCK_SIZE];
 524
 525     memcpy(buf,bitme, LOGICAL_BLOCK_SIZE);
 526 #ifdef LITT_ENDIAN
 527     /* little to big */
 528     swapEndian(buf, SWBL_BITMAPE);
 529 #endif
 530
 531 /*  dumpBlock((unsigned char*)buf);*/
 532     if (adfWriteBlock(vol, nSect, (unsigned char*)buf)!=RC_OK)
 533         return RC_ERROR;
 534
 535     return RC_OK;
 536 }
 537
 538
 539 /*
 540  * adfFreeBitmap
 541  *
 542  */
 543 void adfFreeBitmap(struct Volume* vol)
 544 {
 545     int i;
 546
 547     for(i=0; i<vol->bitmapSize; i++)
 548         free(vol->bitmapTable[i]);
 549     vol->bitmapSize = 0;
 550
 551     free(vol->bitmapTable);
 552     vol->bitmapTable = 0;
 553
 554     free(vol->bitmapBlocks);
 555     vol->bitmapBlocks = 0;
 556
 557     free(vol->bitmapBlocksChg);
 558     vol->bitmapBlocksChg = 0;
 559 }
 560
 561
 562 /*#######################################################################################*/