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