tools/adflib/adf_disk.c

   1 /*
   2  *  ADF Library. (C) 1997-1999 Laurent Clevy
   3  *
   4  *  adf_disk.c
   5  *
   6  * logical disk/volume code
   7  */
   8
   9 #include <limits.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "adf_str.h"
  14 #include "adf_disk.h"
  15 #include "adf_raw.h"
  16 #include "adf_hd.h"
  17 #include "adf_bitm.h"
  18 #include "adf_util.h"
  19 #include "adf_nativ.h"
  20 #include "adf_dump.h"
  21 #include "adf_err.h"
  22 #include "adf_cache.h"
  23
  24 extern struct Env adfEnv;
  25
  26 RETCODE adfInstallBootBlock(struct Volume *vol, unsigned char* code)
  27 {
  28     int i;
  29     struct bBootBlock boot;
  30
  31     if (vol->dev->devType!=DEVTYPE_FLOPDD && vol->dev->devType!=DEVTYPE_FLOPHD)
  32         return RC_ERROR;
  33
  34     if (adfReadBootBlock(vol, &boot)!=RC_OK)
  35         return RC_ERROR;
  36
  37     boot.rootBlock = vol->rootBlock;
  38     for(i=0; i<1024-12; i++)         /* bootcode */
  39         boot.data[i] = code[i+12];
  40
  41     if (adfWriteBootBlock(vol, &boot)!=RC_OK)
  42                 return RC_ERROR;
  43
  44         vol->bootCode = TRUE;
  45
  46     return RC_OK;
  47 }
  48
  49
  50 /*
  51  * isSectNumValid
  52  *
  53  */
  54 BOOL isSectNumValid(struct Volume *vol, SECTNUM nSect)
  55 {
  56     return( 0<=nSect && nSect < vol->totalBlocks);
  57 }
  58
  59
  60
  61 /*
  62  * adfVolumeInfo
  63  *
  64  */
  65 void adfVolumeInfo(struct Volume *vol)
  66 {
  67         struct bRootBlock root;
  68         char diskName[35];
  69         int days,month,year;
  70
  71         if (adfReadRootBlock(vol, vol->rootBlock, &root)!=RC_OK)
  72                 return;
  73
  74         memset(diskName, 0, 35);
  75         memcpy(diskName, root.diskName, root.nameLen);
  76
  77         printf ("Name : %-30s\n",vol->volName);
  78         printf ("Type : ");
  79         switch(vol->dev->devType) {
  80                 case DEVTYPE_FLOPDD:
  81                         printf ("Floppy Double Density : 880 KBytes\n");
  82                         break;
  83                 case DEVTYPE_FLOPHD:
  84                         printf ("Floppy High Density : 1760 KBytes\n");
  85                         break;
  86                 case DEVTYPE_HARDDISK:
  87                         printf ("Hard Disk partition : %3.1f KBytes\n",
  88                                 (vol->totalBlocks) * 512.0/1024.0);
  89                         break;
  90                 case DEVTYPE_HARDFILE:
  91                         printf ("HardFile : %3.1f KBytes\n",
  92                                 (vol->totalBlocks) * 512.0/1024.0);
  93                         break;
  94                 default:
  95                         printf ("Unknown devType!\n");
  96         }
  97         printf ("Filesystem : ");
  98         printf("%s ",isFFS(vol->dosType) ? "FFS" : "OFS");
  99         if (isINTL(vol->dosType))
 100                 printf ("INTL ");
 101         if (isDIRCACHE(vol->dosType))
 102                 printf ("DIRCACHE ");
 103         putchar('\n');
 104
 105     printf("Free blocks = %ld\n", (long)adfCountFreeBlocks(vol));
 106     if (vol->readOnly)
 107         printf("Read only\n");
 108     else
 109         printf("Read/Write\n");
 110
 111     /* created */
 112     adfDays2Date(root.coDays, &year, &month, &days);
 113     printf ("created %d/%02d/%02d %ld:%02ld:%02ld\n",days,month,year,
 114             (long)root.coMins/60,(long)root.coMins%60,(long)root.coTicks/50);
 115         adfDays2Date(root.days, &year, &month, &days);
 116     printf ("last access %d/%02d/%02d %ld:%02ld:%02ld,   ",days,month,year,
 117             (long)root.mins/60,(long)root.mins%60,(long)root.ticks/50);
 118         adfDays2Date(root.cDays, &year, &month, &days);
 119     printf ("%d/%02d/%02d %ld:%02ld:%02ld\n",days,month,year,
 120             (long)root.cMins/60,(long)root.cMins%60,(long)root.cTicks/50);
 121 }
 122
 123
 124
 125 /*
 126  * adfMount
 127  *
 128  *
 129  */
 130 struct Volume* adfMount( struct Device *dev, int nPart, BOOL readOnly )
 131 {
 132     struct bRootBlock root;
 133     struct bBootBlock boot;
 134     struct Volume* vol;
 135
 136     if (dev==NULL || nPart >= dev->nVol) // removed "|| nPart<nPart " .... nonsense comparison?
 137     {
 138         (*adfEnv.eFct)("adfMount : invalid parameter(s)");
 139         return NULL;
 140     }
 141
 142     vol = dev->volList[nPart];
 143     vol->dev = dev;
 144     vol->mounted = TRUE;
 145
 146     if (adfReadBootBlock(vol, &boot)!=RC_OK) {
 147         (*adfEnv.wFct)("adfMount : BootBlock invalid");
 148         return NULL;
 149     }
 150
 151     vol->dosType = boot.dosType[3];
 152     if (isFFS(vol->dosType))
 153         vol->datablockSize=512;
 154     else
 155         vol->datablockSize=488;
 156
 157     if (dev->readOnly /*|| isDIRCACHE(vol->dosType)*/)
 158        vol->readOnly = TRUE;
 159     else
 160        vol->readOnly = readOnly;
 161
 162     vol->rootBlock = boot.rootBlock;
 163
 164     if (adfReadRootBlock(vol, vol->rootBlock, &root)!=RC_OK) {
 165         (*adfEnv.wFct)("adfMount : RootBlock invalid");
 166         return NULL;
 167     }
 168
 169     adfReadBitmap( vol, &root );
 170     vol->curDirPtr = vol->rootBlock;
 171
 172 //printf("blockSize=%d\n",vol->blockSize);
 173
 174     return( vol );
 175 }
 176
 177
 178 /*
 179 *
 180 * adfUnMount
 181 *
 182 * free bitmap structures
 183 * free current dir
 184 */
 185 void adfUnMount(struct Volume *vol)
 186 {
 187         if (!vol) {
 188                 (*adfEnv.eFct)("adfUnMount : vol is null");
 189         return;
 190     }
 191
 192     adfFreeBitmap(vol);
 193
 194     vol->mounted = FALSE;
 195
 196 }
 197
 198
 199
 200 /*
 201  * adfCreateVol
 202  *
 203  *
 204  */
 205 struct Volume* adfCreateVol( struct Device* dev, ULONG start, ULONG len, int reserved,
 206     char* volName, int dosType )
 207 {
 208     struct bBootBlock boot;
 209     struct bRootBlock root;
 210 //    struct bDirCacheBlock dirc;
 211     SECTNUM blkList[2];
 212     struct Volume* vol;
 213     int nlen;
 214
 215     if (adfEnv.useProgressBar)
 216         (*adfEnv.progressBar)(0);
 217
 218     vol=(struct Volume*)malloc(sizeof(struct Volume));
 219     if (!vol) {
 220                 (*adfEnv.eFct)("adfCreateVol : malloc vol");
 221         return NULL;
 222     }
 223
 224     /* It is illegal to have 0 reserved blocks */
 225     if (reserved <= 0)
 226         reserved = 2;
 227
 228     vol->dev = dev;
 229     vol->firstBlock = (dev->heads * dev->sectors)*start;
 230     vol->totalBlocks = (dev->heads * dev->sectors)*len;
 231     vol->reservedBlocks = reserved;
 232     vol->rootBlock = (vol->totalBlocks-1 + reserved)/2;
 233     vol->curDirPtr = vol->rootBlock;
 234     vol->dosType = dosType;
 235
 236     vol->readOnly = dev->readOnly;
 237
 238     vol->mounted = TRUE;
 239
 240     nlen = min( MAXNAMELEN, strlen(volName) );
 241     vol->volName = (char*)malloc(nlen+1);
 242     if (!vol->volName) {
 243                 (*adfEnv.eFct)("adfCreateVol : malloc");
 244                 free(vol); return NULL;
 245     }
 246     memcpy(vol->volName, volName, nlen);
 247     vol->volName[nlen]='\0';
 248
 249     if (adfEnv.useProgressBar)
 250         (*adfEnv.progressBar)(25);
 251
 252     memset(&boot, 0, sizeof(boot));
 253     if (adfWriteBootBlock(vol, &boot)!=RC_OK) {
 254         free(vol->volName); free(vol);
 255         return NULL;
 256     }
 257
 258     if (adfEnv.useProgressBar)
 259         (*adfEnv.progressBar)(20);
 260
 261     if (adfCreateBitmap( vol )!=RC_OK) {
 262         free(vol->volName); free(vol);
 263         return NULL;
 264     }
 265
 266     if (adfEnv.useProgressBar)
 267         (*adfEnv.progressBar)(40);
 268
 269
 270 /*for(i=0; i<127; i++)
 271 printf("%3d %x, ",i,vol->bitmapTable[0]->map[i]);
 272 */
 273     if ( isDIRCACHE(dosType) )
 274         adfGetFreeBlocks( vol, 1, blkList );
 275
 276
 277 /*printf("[0]=%d [1]=%d\n",blkList[0],blkList[1]);*/
 278
 279     memset(&root, 0, sizeof(root));
 280
 281     if (strlen(volName)>MAXNAMELEN)
 282         volName[MAXNAMELEN]='\0';
 283     root.nameLen = strlen(volName);
 284     memcpy(root.diskName,volName,root.nameLen);
 285     adfTime2AmigaTime(adfGiveCurrentTime(),&(root.coDays),&(root.coMins),&(root.coTicks));
 286
 287     /* dircache block */
 288     if ( isDIRCACHE(dosType) ) {
 289         root.extension = 0L;
 290         root.secType = ST_ROOT; /* needed by adfCreateEmptyCache() */
 291         adfCreateEmptyCache(vol, (struct bEntryBlock*)&root, blkList[0]);
 292     }
 293
 294     if (adfEnv.useProgressBar)
 295         (*adfEnv.progressBar)(60);
 296
 297     if (adfWriteRootBlock(vol, vol->rootBlock, &root)!=RC_OK) {
 298         free(vol->volName); free(vol);
 299         return NULL;
 300     }
 301
 302    /* fills root->bmPages[] and writes filled bitmapExtBlocks */
 303     if (adfWriteNewBitmap(vol)!=RC_OK)
 304                 return NULL;
 305
 306     if (adfEnv.useProgressBar)
 307         (*adfEnv.progressBar)(80);
 308
 309     if (adfUpdateBitmap(vol)!=RC_OK)
 310                 return NULL;
 311
 312     if (adfEnv.useProgressBar)
 313         (*adfEnv.progressBar)(100);
 314 //printf("free blocks %ld\n",adfCountFreeBlocks(vol));
 315
 316     /* will be managed by adfMount() later */
 317     adfFreeBitmap(vol);
 318
 319     vol->mounted = FALSE;
 320
 321     return(vol);
 322 }
 323
 324
 325 /*-----*/
 326
 327 /*
 328  * adfReadBlock
 329  *
 330  * read logical block
 331  */
 332 RETCODE
 333 adfReadBlock(struct Volume* vol, ULONG nSect, unsigned char* buf)
 334 {
 335   /*    char strBuf[80];*/
 336     ULONG pSect;
 337     struct nativeFunctions *nFct;
 338     RETCODE rc;
 339
 340     if (!vol->mounted) {
 341         (*adfEnv.eFct)("the volume isn't mounted, adfReadBlock not possible");
 342         return RC_ERROR;
 343     }
 344
 345     if (nSect >= vol->totalBlocks)
 346         (*adfEnv.wFct)("adfReadBlock : nSect out of range");
 347
 348     /* translate logical sect to physical sect */
 349     pSect = nSect+vol->firstBlock;
 350
 351     if (adfEnv.useRWAccess)
 352         (*adfEnv.rwhAccess)(pSect,nSect,FALSE);
 353
 354 //printf("psect=%ld nsect=%ld\n",pSect,nSect);
 355 /*    sprintf(strBuf,"ReadBlock : accessing logical block #%ld", nSect);
 356     (*adfEnv.vFct)(strBuf);
 357 */
 358 //printf("pSect R =%ld\n",pSect);
 359     nFct = adfEnv.nativeFct;
 360     if (vol->dev->isNativeDev)
 361         rc = (*nFct->adfNativeReadSector)(vol->dev, pSect, 512, buf);
 362     else
 363         rc = adfReadDumpSector(vol->dev, pSect, 512, buf);
 364 //printf("rc=%ld\n",rc);
 365
 366     if (rc!=RC_OK) {
 367         (*adfEnv.wFct)("adfReadBlock : Can't read sector");
 368         return RC_ERROR;
 369     } else
 370         return RC_OK;
 371 }
 372
 373
 374 /*
 375  * adfWriteBlock
 376  *
 377  */
 378 RETCODE adfWriteBlock(struct Volume* vol, ULONG nSect, unsigned char *buf)
 379 {
 380     ULONG pSect;
 381     struct nativeFunctions *nFct;
 382     RETCODE rc;
 383
 384     if (!vol->mounted) {
 385         (*adfEnv.eFct)("the volume isn't mounted, adfWriteBlock not possible");
 386         return RC_ERROR;
 387     }
 388
 389     if (vol->readOnly) {
 390         (*adfEnv.wFct)("adfWriteBlock : can't write block, read only volume");
 391         return RC_ERROR;
 392     }
 393
 394     if (nSect >= vol->totalBlocks) {
 395         (*adfEnv.wFct)("adfWriteBlock : nSect out of range");
 396     }
 397
 398     pSect = nSect+vol->firstBlock;
 399 //printf("write nsect=%ld psect=%ld\n",nSect,pSect);
 400
 401     if (adfEnv.useRWAccess)
 402         (*adfEnv.rwhAccess)(pSect,nSect,TRUE);
 403
 404     nFct = adfEnv.nativeFct;
 405     if (vol->dev->isNativeDev)
 406         rc = (*nFct->adfNativeWriteSector)(vol->dev, pSect, 512, buf);
 407     else
 408         rc = adfWriteDumpSector(vol->dev, pSect, 512, buf);
 409
 410     if (rc!=RC_OK)
 411         return RC_ERROR;
 412     else
 413         return RC_OK;
 414 }
 415
 416
 417
 418 /*#######################################################################################*/