TempleOSCDV5.02.ISO

Kernel/BlkDev/FileSysRedSea.HC

@@ -32,7 +32,7 @@ U0 RedSeaFreeLstBuild(CDrv *dv)
       RedSeaFreeFreeLst(dv);
     QueInit(&dv->next_free);
     while (first<max_blk) {
-      i=0;  //count free clusters
+      i=0;  //count free clus
       while (first+i<max_blk) {
 	DrvFATBlkSet(dv,first+i);
 	if (Bt(dv->cur_fat_blk,(first+i-dv->data_area)&(BLK_SIZE<<3-1)))
@@ -61,7 +61,7 @@ U0 RedSeaInit(CDrv *dv)
   Bool unlock;
   try {
     unlock=DrvLock(dv);
-    RBlks(dv,&br,dv->drv_offset,1);
+    BlkRead(dv,&br,dv->drv_offset,1);
     if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
       throw('Drv');
     dv->fs_type=FSt_REDSEA;
@@ -69,7 +69,7 @@ U0 RedSeaInit(CDrv *dv)
     dv->spc=1;
     dv->size=br.sects;
     dv->data_area=dv->drv_offset+br.bitmap_sects;
-    dv->root_cluster=br.root_cluster;
+    dv->root_clus=br.root_clus;
     dv->fat1=dv->fat2=dv->drv_offset+1;
     DrvFATBlkAlloc(dv);
     if (unlock)
@@ -84,7 +84,7 @@ Bool RedSeaValidate(U8 drv_let)
   CDrv *dv;
   CRedSeaBoot br;
   if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA &&
-	RBlks(dv,&br,dv->drv_offset,1) && br.signature==MBR_PT_REDSEA &&
+	BlkRead(dv,&br,dv->drv_offset,1) && br.signature==MBR_PT_REDSEA &&
 	br.signature2==0xAA55 && br.sects==dv->size)
     return TRUE;
   else
@@ -110,28 +110,28 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     n=(br->sects+BLK_SIZE<<3-1)/BLK_SIZE<<3;
     br->bitmap_sects=n;
     br->unique_id=GetTSC^Now()(U64);
-    br->root_cluster=0;
+    br->root_clus=0;
 
     if (quick)
       i=n+1;
     else
       i=dv->size;
-    WZeroBlks(dv,dv->drv_offset,i);
+    BlkWriteZero(dv,dv->drv_offset,i);
 
-    WBlks(dv,br,dv->drv_offset,1);
+    BlkWrite(dv,br,dv->drv_offset,1);
     RedSeaInit(dv);
-    ClustersAlloc(dv,0,1,FALSE);	//Alloc #1
+    ClusAlloc(dv,0,1,FALSE);	//Alloc #1
 
     root_dir_blks=MaxI64(1,dv->bd->init_root_dir_blks);
-    br->root_cluster=ClustersAlloc(dv,0,root_dir_blks,FALSE);
-    WBlks(dv,br,dv->drv_offset,1);
+    br->root_clus=ClusAlloc(dv,0,root_dir_blks,FALSE);
+    BlkWrite(dv,br,dv->drv_offset,1);
     root_dir=CAlloc(BLK_SIZE*root_dir_blks);
 
     d_native=root_dir-offset(CDirEntry.start);
 
     d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
     *d_native->name='.';
-    d_native->cluster=br->root_cluster;
+    d_native->clus=br->root_clus;
     d_native->size=BLK_SIZE*root_dir_blks;
     d_native->datetime=Now;
 
@@ -140,10 +140,10 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     *d_native->name='.';
     d_native->name[1]='.';
     d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
-    d_native->cluster=br->root_cluster;
+    d_native->clus=br->root_clus;
     d_native->datetime=Now;
 
-    WBlks(dv,root_dir,br->root_cluster,root_dir_blks);
+    BlkWrite(dv,root_dir,br->root_clus,root_dir_blks);
     RedSeaInit(dv);
     DrvUnlock(dv);
   } catch
@@ -152,7 +152,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
   Free(root_dir);
 }
 
-Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
+Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_clus,U8 *name,
 	CDirEntry *_res,I64 fuf_flags=0)
 {//$LK,"FUF_JUST_DIRS",A="MN:FUF_JUST_DIRS"$, $LK,"FUF_JUST_FILES",A="MN:FUF_JUST_FILES"$
   CDirEntry *buf,*buf2,*ptr;
@@ -171,11 +171,11 @@ Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
     try {
       unlock=DrvLock(dv);
       buf2=MAlloc(BLK_SIZE);
-      RBlks(dv,buf2,cur_dir_cluster,1);
+      BlkRead(dv,buf2,cur_dir_clus,1);
 
       ptr=buf2(U8 *)-offset(CDirEntry.start);
       buf=MAlloc(ptr->size);
-      RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
+      BlkRead(dv,buf,cur_dir_clus,ptr->size>>BLK_SIZE_BITS);
       Free(buf2);
 
       ptr=buf(U8 *)-offset(CDirEntry.start);
@@ -208,7 +208,7 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
 {
   U8 *buf=NULL;
   CDirEntry de;
-  I64 c,blk_cnt,cur_dir_cluster;
+  I64 c,blk_cnt,cur_dir_clus;
   DrvChk(dv);
   *_size=0;
   *_attr=0;
@@ -217,12 +217,12 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
   else
     try {
       DrvLock(dv);
-      cur_dir_cluster=Name2DirCluster(dv,cur_dir);
-      if (RedSeaFileFind(dv,cur_dir_cluster,filename,&de,FUF_JUST_FILES)) {
+      cur_dir_clus=Name2DirClus(dv,cur_dir);
+      if (RedSeaFileFind(dv,cur_dir_clus,filename,&de,FUF_JUST_FILES)) {
 	blk_cnt=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
 	buf=MAlloc(blk_cnt<<BLK_SIZE_BITS+1);
-	c=de.cluster;
-	c=RBlks(dv,buf,c,blk_cnt);
+	c=de.clus;
+	c=BlkRead(dv,buf,c,blk_cnt);
 	buf[de.size]=0; //Terminate
 	*_size=de.size;
 	*_attr=FileAttr(de.name,de.attr);
@@ -233,12 +233,12 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
   return buf;
 }
 
-Bool RedSeaCd(U8 *name,I64 cur_dir_cluster)
+Bool RedSeaCd(U8 *name,I64 cur_dir_clus)
 {
   CDirEntry de;
   if (Fs->cur_dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
-  else if (RedSeaFileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
+  else if (RedSeaFileFind(Fs->cur_dv,cur_dir_clus,name,&de,FUF_JUST_DIRS))
     return TRUE;
   else {
     "%s ",name;
@@ -247,7 +247,7 @@ Bool RedSeaCd(U8 *name,I64 cur_dir_cluster)
   return FALSE;
 }
 
-U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
+U0 RedSeaFreeClus(CDrv *dv,I64 c,I64 cnt)
 {
   CFreeLst *tmpf;
   Bool found=FALSE,unlock,unlock_break;
@@ -299,7 +299,7 @@ U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
     }
 }
 
-I64 RedSeaAllocClusters(CDrv *dv,I64 cnt)
+I64 RedSeaAllocClus(CDrv *dv,I64 cnt)
 {
   CFreeLst *tmpf,*best_free=NULL;
   I64 i,first,best_size=I64_MAX;
@@ -353,20 +353,20 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
 {
   CDirEntry *buf,*buf2,*ptr,de2;
   CRedSeaBoot *br;
-  I64 c,ch,i=1,j=0,n=BLK_SIZE/CDIR_SIZE,dir_size,cur_dir_cluster;
+  I64 c,ch,i=1,j=0,n=BLK_SIZE/CDIR_SIZE,dir_size,cur_dir_clus;
   Bool written=FALSE,unlock,unlock_break;
   U8 *tmp,*parent_dir;
   try {
     unlock_break=BreakLock;
     tmpde->attr|=RS_ATTR_CONTIGUOUS;
     unlock=DrvLock(dv);
-    cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+    cur_dir_clus=Name2DirClus(dv,cur_dir);
     buf2=MAlloc(BLK_SIZE);
-    RBlks(dv,buf2,cur_dir_cluster,1);
+    BlkRead(dv,buf2,cur_dir_clus,1);
 
     ptr=buf2(U8 *)-offset(CDirEntry.start);
     buf=MAlloc(ptr->size);
-    RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
+    BlkRead(dv,buf,cur_dir_clus,ptr->size>>BLK_SIZE_BITS);
 
     dir_size=ptr->size;
     ptr=buf(U8 *)-offset(CDirEntry.start)+CDIR_SIZE;
@@ -376,26 +376,26 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
 	if (!written)
 	  MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
 	if ((i+1)*CDIR_SIZE+j<<BLK_SIZE_BITS<dir_size)
-	  WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
+	  BlkWrite(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
 	else {
 	  buf2=CAlloc(dir_size+BLK_SIZE);
 	  MemCpy(buf2,buf,dir_size);
-	  RedSeaFreeClusters(dv,cur_dir_cluster,dir_size>>BLK_SIZE_BITS);
+	  RedSeaFreeClus(dv,cur_dir_clus,dir_size>>BLK_SIZE_BITS);
 	  dir_size+=BLK_SIZE;
-	  c=ClustersAlloc(dv,0,dir_size>>BLK_SIZE_BITS,TRUE);
+	  c=ClusAlloc(dv,0,dir_size>>BLK_SIZE_BITS,TRUE);
 	  Free(buf);
 	  buf=buf2;
 	  ptr=buf(U8 *)-offset(CDirEntry.start);
 	  ptr->size=dir_size;
-	  ptr->cluster=c;
-	  WBlks(dv,buf,c,dir_size>>BLK_SIZE_BITS);
-	  if (cur_dir_cluster==dv->root_cluster) {
+	  ptr->clus=c;
+	  BlkWrite(dv,buf,c,dir_size>>BLK_SIZE_BITS);
+	  if (cur_dir_clus==dv->root_clus) {
 	    br=CAlloc(BLK_SIZE);
-	    RBlks(dv,br,dv->drv_offset,1);
-	    br->root_cluster=c;
-	    WBlks(dv,br,dv->drv_offset,1);
+	    BlkRead(dv,br,dv->drv_offset,1);
+	    br->root_clus=c;
+	    BlkWrite(dv,br,dv->drv_offset,1);
 	    Free(br);
-	    dv->root_cluster=c;
+	    dv->root_clus=c;
 	  } else {
 	    tmp=StrNew(cur_dir);
 	    parent_dir=StrNew(cur_dir);
@@ -404,9 +404,9 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
 	      Free(parent_dir);
 	      parent_dir=StrNew("/");
 	    }
-	    if (RedSeaFileFind(dv,Name2DirCluster(dv,parent_dir),
+	    if (RedSeaFileFind(dv,Name2DirClus(dv,parent_dir),
 		  tmp,&de2,FUF_JUST_DIRS)) {
-	      de2.cluster=c;
+	      de2.clus=c;
 	      de2.size=dir_size;
 	      RedSeaDirNew(dv,parent_dir,&de2,FALSE);
 	    } else
@@ -419,19 +419,19 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tmpde,Bool free_old_chain)
       } else if (ptr->attr & RS_ATTR_DELETED) {
 	if (!written) {
 	  MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
-	  WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
+	  BlkWrite(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
 	  written=TRUE;
 	}
       } else {
 	if (!StrCmp(tmpde->name,ptr->name)) {
 	  if (free_old_chain)
-	    RedSeaFreeClusters(dv,ptr->cluster,
+	    RedSeaFreeClus(dv,ptr->clus,
 		  (ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
 	  if (!written)
 	    MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE);
 	  else
 	    ptr->attr|=RS_ATTR_DELETED;
-	  WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
+	  BlkWrite(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
 	  break;
 	}
       }
@@ -459,18 +459,18 @@ I64 RedSeaFilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
 		     Bool del_dir,Bool print_msg)
 {
   CDirEntry *buf,*buf2,*ptr;
-  I64 i=0,res=0,ch,j=0,n=BLK_SIZE/CDIR_SIZE,cur_dir_cluster;
+  I64 i=0,res=0,ch,j=0,n=BLK_SIZE/CDIR_SIZE,cur_dir_clus;
   Bool unlock_break;
   try {
     unlock_break=BreakLock;
     DrvLock(dv);
-    cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+    cur_dir_clus=Name2DirClus(dv,cur_dir);
     buf2=MAlloc(BLK_SIZE);
-    RBlks(dv,buf2,cur_dir_cluster,1);
+    BlkRead(dv,buf2,cur_dir_clus,1);
 
     ptr=buf2(U8 *)-offset(CDirEntry.start);
     buf=MAlloc(ptr->size);
-    RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
+    BlkRead(dv,buf,cur_dir_clus,ptr->size>>BLK_SIZE_BITS);
     Free(buf2);
 
     ptr=buf(U8 *)-offset(CDirEntry.start);
@@ -486,8 +486,8 @@ I64 RedSeaFilesDel(CDrv *dv,U8 *cur_dir,U8 *files_find_mask,I64 fuf_flags,
 	if (print_msg)
 	  "Del %s\n",ptr->name;
 	ptr->attr|=RS_ATTR_DELETED;
-	WBlks(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_cluster+j,1);
-	RedSeaFreeClusters(dv,ptr->cluster,
+	BlkWrite(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1);
+	RedSeaFreeClus(dv,ptr->clus,
 	      (ptr->size+BLK_SIZE-1)>>BLK_SIZE_BITS);
       }
       ptr(U8 *)+=CDIR_SIZE;
@@ -523,14 +523,14 @@ I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
     RedSeaFilesDel(dv,cur_dir,de.name,0,FALSE,FALSE);
     de.size=size;
     if (blk_cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS)
-      c=ClustersAlloc(dv,0,blk_cnt,TRUE); //Always contiguous
+      c=ClusAlloc(dv,0,blk_cnt,TRUE); //Always contiguous
     else
-      c=INVALID_CLUSTER;
-    de.cluster=c;
+      c=INVALID_CLUS;
+    de.clus=c;
     de.attr=attr|RS_ATTR_CONTIGUOUS;
     de.datetime=cdt;
     if (blk_cnt)
-      WBlks(dv,buf,c,blk_cnt);
+      BlkWrite(dv,buf,c,blk_cnt);
     RedSeaDirNew(dv,cur_dir,&de,TRUE);
   }
   return c;
@@ -541,25 +541,25 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
 {
   CDrv *dv=Fs->cur_dv;
   CDirEntry *buf,*buf2,*ptr,*res=NULL,*tmpde;
-  I64 ch,cur_dir_cluster;
+  I64 ch,cur_dir_clus;
   if (fuf_flags&~FUG_FILES_FIND)
     throw('FUF');
   try {
     DrvLock(dv);
-    cur_dir_cluster=Name2DirCluster(dv,Fs->cur_dir);
+    cur_dir_clus=Name2DirClus(dv,Fs->cur_dir);
     buf2=MAlloc(BLK_SIZE);
-    RBlks(dv,buf2,cur_dir_cluster,1);
+    BlkRead(dv,buf2,cur_dir_clus,1);
 
     ptr=buf2(U8 *)-offset(CDirEntry.start);
     buf=MAlloc(ptr->size);
-    RBlks(dv,buf,cur_dir_cluster,ptr->size>>BLK_SIZE_BITS);
+    BlkRead(dv,buf,cur_dir_clus,ptr->size>>BLK_SIZE_BITS);
     Free(buf2);
 
     ptr=buf(U8 *)-offset(CDirEntry.start);
     *ptr->name='.';
     ptr->name[1]=0;
     ptr(U8 *)+=CDIR_SIZE;
-    ptr->cluster=Name2ParentDirCluster(dv,Fs->cur_dir);
+    ptr->clus=Name2ParentDirClus(dv,Fs->cur_dir);
     ptr(U8 *)-=CDIR_SIZE;
     while (TRUE) {
       if (!(ch=*ptr->name))
@@ -603,7 +603,7 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
 
 Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
 {//entry_cnt is for preallocating dir blks.
-  I64	c,cur_dir_cluster=Name2DirCluster(dv,cur_dir),
+  I64	c,cur_dir_clus=Name2DirClus(dv,cur_dir),
 	size=CeilU64((entry_cnt+3)<<6,BLK_SIZE);
 #assert CDIR_SIZE==64
   U8 *buf=CAlloc(size);
@@ -614,7 +614,7 @@ Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
     c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
     d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
     StrCpy(d_native->name,name);
-    d_native->cluster=c;
+    d_native->clus=c;
     d_native->size=size;
     d_native->datetime=Now;
     d_native(U8 *)+=CDIR_SIZE;
@@ -623,10 +623,10 @@ Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
     *d_native->name='.';
     d_native->name[1]='.';
     d_native->name[2]=0;
-    d_native->cluster=cur_dir_cluster;
+    d_native->clus=cur_dir_clus;
     d_native->size=0;
     d_native->datetime=Now;
-    WBlks(dv,buf,c,1);
+    BlkWrite(dv,buf,c,1);
     Free(buf);
     if (unlock_break)
       BreakUnlock;