TempleOSCDV4.08.ISO

Kernel/BlkDev/DskATA.CPP

@@ -1,4 +1,4 @@
-U0 ATABlkSelect(CBlkDev *bd,I64 blk,I64 cnt)
+U0 ATABlkSel(CBlkDev *bd,I64 blk,I64 cnt)
 {
   if (bd->type!=BDT_ATAPI && bd->base1)
     OutU8(bd->base1+ATAR1_CTRL,0x8);
@@ -11,13 +11,13 @@ U0 ATABlkSelect(CBlkDev *bd,I64 blk,I64 cnt)
     OutU8(bd->base0+ATAR0_SECT,blk);
     OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
     OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   } else { //28 Bit LBA
     OutU8(bd->base0+ATAR0_NSECT,cnt);
     OutU8(bd->base0+ATAR0_SECT,blk);
     OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
     OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4|blk.u8[3]);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4|blk.u8[3]);
   }
 }
 
@@ -48,9 +48,9 @@ Bool ATAWaitDRQ(CBlkDev *bd,F64 timeout)
 Bool ATANop(CBlkDev *bd,F64 timeout)
 {
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_FEAT,0);
   OutU8(bd->base0+ATAR0_CMD,ATA_NOP);
   return ATAWaitNotBUSY(bd,timeout);
@@ -118,9 +118,9 @@ Bool ATAPIWritePktWord(CBlkDev *bd,F64 timeout,...)
 Bool ATAPISetMaxSpeed(CBlkDev *bd)
 {
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_LCYL,0);
   OutU8(bd->base0+ATAR0_HCYL,0);
   ATACmd(bd,ATA_PACKET);
@@ -131,9 +131,9 @@ Bool ATAPISetMaxSpeed(CBlkDev *bd)
 Bool ATAPISeek(CBlkDev *bd,I64 native_blk)
 {
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_LCYL,0);
   OutU8(bd->base0+ATAR0_HCYL,0);
   ATACmd(bd,ATA_PACKET);
@@ -149,9 +149,9 @@ Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start)
   else
     i=0;
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   ATACmd(bd,ATA_PACKET);
 //Start/Stop
   if (ATAPIWritePktWord(bd,timeout,0x1B00,0,i,0,0,0))
@@ -167,9 +167,9 @@ I64 ATAGetDevId(CBlkDev *bd,F64 timeout,U16 **_id_record)
   if (bd->type!=BDT_ATAPI && bd->base1)
     OutU8(bd->base1+ATAR1_CTRL,0x8);
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   ATACmd(bd,ATA_ID_DEV);
   if (!ATAWaitNotBUSY(bd,timeout))
     return BDT_NULL;
@@ -191,9 +191,9 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
 
   if (bd->type==BDT_ATAPI) {
     if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
     else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
     ATACmd(bd,ATA_DEV_RST);
     if (!ATAWaitNotBUSY(bd,0))
       okay=FALSE;
@@ -217,7 +217,7 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
   if (okay) {
     if (bd->flags & BDF_EXT_SIZE && bd->base1) {
       OutU8(bd->base1+ATAR1_CTRL,0x8);
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
       ATACmd(bd,ATA_READ_NATIVE_MAX_EXT);
       if (ATAWaitNotBUSY(bd,timeout)) {
 	res.u8[0]=InU8(bd->base0+ATAR0_SECT);
@@ -237,13 +237,13 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
     } else {
       if (bd->type!=BDT_ATAPI && bd->base1)
 	OutU8(bd->base1+ATAR1_CTRL,0x8);
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
       ATACmd(bd,ATA_READ_NATIVE_MAX);
       if (ATAWaitNotBUSY(bd,timeout)) {
 	res.u8[0]=InU8(bd->base0+ATAR0_SECT);
 	res.u8[1]=InU8(bd->base0+ATAR0_LCYL);
 	res.u8[2]=InU8(bd->base0+ATAR0_HCYL);
-	res.u8[3]=InU8(bd->base0+ATAR0_SELECT) & 0xF;
+	res.u8[3]=InU8(bd->base0+ATAR0_SEL) & 0xF;
       }
     }
   }
@@ -257,9 +257,9 @@ I64 ATAPIReadCapacity(CBlkDev *bd,I64 *_blk_size=NULL)
   U32 buf[2];
   if (ATAWaitNotBUSY(bd,0)) {
     if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
     else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
     OutU8(bd->base0+ATAR0_LCYL,8);
     OutU8(bd->base0+ATAR0_HCYL,0);
     ATACmd(bd,ATA_PACKET);
@@ -280,9 +280,9 @@ CATAPITrack *ATAPIReadTrackInfo(CBlkDev *bd,I64 blk)
   Bool unlock=BlkDevLock(bd);
   if (ATAWaitNotBUSY(bd,0)) {
     if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
     else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
     OutU8(bd->base0+ATAR0_LCYL,sizeof(CATAPITrack)&0xFF);
     OutU8(bd->base0+ATAR0_HCYL,sizeof(CATAPITrack)>>8);
     ATACmd(bd,ATA_PACKET);
@@ -311,7 +311,7 @@ Bool ATAInit(CBlkDev *bd)
 
   if (ATAReadNativeMax(bd,tS+0.1)) {
 
-    ATABlkSelect(bd,bd->max_blk,0);
+    ATABlkSel(bd,bd->max_blk,0);
     if (bd->flags&BDF_EXT_SIZE)
       ATACmd(bd,ATA_SET_MAX_EXT);
     else
@@ -353,7 +353,7 @@ U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
   Bool unlock=BlkDevLock(bd);
 
   retry:
-  ATABlkSelect(bd,blk,cnt);
+  ATABlkSel(bd,blk,cnt);
   if (bd->flags & BDF_EXT_SIZE)
     ATACmd(bd,ATA_READ_MULTI_EXT);
   else
@@ -392,9 +392,9 @@ Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf,
     unlock=BlkDevLock(bd);
   if (ATAPIWaitReady(bd,timeout)) {
     if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
     else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
     OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
     OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
     ATACmd(bd,ATA_PACKET);
@@ -421,8 +421,8 @@ U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
       blk2=0;
     else
       blk2=FloorU64(blk-bd->max_reads,spc);
-    if (blk2+l2>dv->size)
-      l2=dv->size-blk2;
+    if (blk2+l2>dv->size+dv->drv_offset)
+      l2=dv->size+dv->drv_offset-blk2;
     n=(l2+spc-1)/spc;
 
     retry=4;
@@ -465,7 +465,7 @@ U0 ATAWriteBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
   F64 timeout;
   Bool unlock=BlkDevLock(bd);
 retry:
-  ATABlkSelect(bd,blk,cnt);
+  ATABlkSel(bd,blk,cnt);
   if (bd->flags&BDF_EXT_SIZE)
     ATACmd(bd,ATA_WRITE_MULTI_EXT);
   else
@@ -505,9 +505,9 @@ Bool ATAPISync(CBlkDev *bd)
     okay=FALSE;
   else {
     if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
     else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
     OutU8(bd->base0+ATAR0_LCYL,0);
     OutU8(bd->base0+ATAR0_HCYL,0);
     ATACmd(bd,ATA_PACKET);
@@ -522,9 +522,9 @@ U0 ATAPIClose(CBlkDev *bd,I64 close_field=0x200,I64 track=0)
 {//0x200 CD/DVD part 1
 // 0x300    DVD part 2
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_LCYL,0);
   OutU8(bd->base0+ATAR0_HCYL,0);
   ATACmd(bd,ATA_PACKET);
@@ -543,9 +543,9 @@ U0 ATAPIWriteBlks(CBlkDev *bd,U8 *buf, I64 native_blk, I64 cnt)
   OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
   OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_CMD,ATA_PACKET);
   ATAPIWritePktWord(bd,0,0x0400,native_blk.u16[1],native_blk,cnt.u16[1],cnt,0);
   bd->flags|=BDF_LAST_WAS_WRITE;
@@ -554,9 +554,9 @@ U0 ATAPIWriteBlks(CBlkDev *bd,U8 *buf, I64 native_blk, I64 cnt)
   ATAPISeek(bd,native_blk);
 
   if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
   else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
   OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
   OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
   ATACmd(bd,ATA_PACKET);

Kernel/BlkDev/DskATAId.CPP

@@ -1,6 +1,6 @@
 Bool BootDVDProve(CBlkDev *bd)
 {
-  CKernel *img=CAlloc(DVD_BLK_SIZE);
+  U8 *img=CAlloc(DVD_BLK_SIZE);
   I64 i;
   Bool res=FALSE;
   "Port: %04X,%04X Unit: %02X  ",bd->base0,bd->base1,bd->unit;
@@ -9,8 +9,9 @@ Bool BootDVDProve(CBlkDev *bd)
     if (ATAPIStartStop(bd,tS+5.0,TRUE)) {
       " Started";
       for (i=0;i<2;i++) {//Retry
-	if (ATAPIReadBlks2(bd,tS+7.0,img,sys_boot_src.u16[1],1,FALSE)) {
-	  if (img->compile_time==sys_compile_time) {
+	if (ATAPIReadBlks2(bd,tS+7.0,img,sys_boot_blk,1,FALSE)) {
+	  if ((img+sys_boot_src.u16[1]<<BLK_SIZE_BITS)(CKernel *)
+		->compile_time==sys_compile_time) {
 	    " Found";
 	    return TRUE;
 	  } else
@@ -201,13 +202,12 @@ CATARep *ATARepFind(CATARep *haystack_root,I64 needle_num)
   return NULL;
 }
 
-CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,
-		CATARep **_ata_drv,CATARep **_atapi_drv)
+CATARep *ATAIDDrvs(CATARep *root,CATARep **_ata_drv,CATARep **_atapi_drv)
 {//This is for when trying to sort-out main hard drives and CD/DVD drives.
   CATARep *res=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
   CBlkDev *bd;
   Bool was_silent=Silent;
-  bd=Let2BlkDev(_sys_boot_drv,FALSE);
+  bd=Let2BlkDev(':',FALSE);
   Silent(was_silent);
   while (tempha) {
     if (!res && bd && bd->type==tempha->type) {
@@ -258,7 +258,7 @@ I64 AutoMountIDE()
   I64 res=0;
   CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL,*tempha;
   ATARep(FALSE,TRUE,&root);
-  ATAIDDrvs(root,blkdev.boot_drv_let,&ata_drv,&atapi_drv);
+  ATAIDDrvs(root,&ata_drv,&atapi_drv);
   if (ata_drv && ATAMount(blkdev.first_hd_drv_let,BDT_ATA,
 	ata_drv->base0,ata_drv->base1,ata_drv->unit))
     res++;

Kernel/BlkDev/DskAddDev.CPP

@@ -5,6 +5,9 @@ U0 BlkDevLockFwdingSet(CBlkDev *bd)
   switch (bd->type) {
     case BDT_RAM:
       break;
+    case BDT_FILE:
+      bd->lock_fwding=Let2BlkDev(*bd->file_dsk_name);
+      break;
     case BDT_ATA:
     case BDT_ATAPI:
       for (i=0;i<NUM_BLKDEVS;i++) {
@@ -33,9 +36,11 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
   else
     dv=DrvNextFree(bd->first_drv_let+res);
   dv->bd=bd;
-  dv->size=bd->max_blk+1;
+  dv->drv_offset=bd->drv_offset;
+  dv->size=bd->max_blk+1-bd->drv_offset;
   switch (bd->type) {
     case BDT_RAM:
+    case BDT_FILE:
       dv->dv_signature=DRV_SIGNATURE_VAL;
       dv->fs_type=FSt_REDSEA;
 //This is to force creation of a RAM
@@ -60,7 +65,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	  dv->dv_signature=DRV_SIGNATURE_VAL;
 	  res++;
 	  dv->fs_type=FSt_REDSEA;
-	  dv->size=bd->max_blk+1;
+	  dv->size=bd->max_blk+1-bd->drv_offset;
 //The following read is a test read.
 	  //if it hangs, the drive is not supported.
 	  ATAReadBlks(bd,&mbr,0,1);
@@ -80,7 +85,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	      else
 		dv=DrvNextFree(bd->first_drv_let+res);
 	      dv->bd=bd;
-	      dv->base_offset=mbr.p[i].offset+offset;
+	      dv->drv_offset=mbr.p[i].offset+offset;
 	      dv->size	=mbr.p[i].size;
 	      switch (mbr.p[i].type) {
 		case MBR_PT_REDSEA:
@@ -95,7 +100,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		case MBR_PT_FAT32d:
 		case MBR_PT_FAT32e:
 		case MBR_PT_FAT32f:
-		  ATAReadBlks(bd,&br,dv->base_offset,1);
+		  ATAReadBlks(bd,&br,dv->drv_offset,1);
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  res++;
 		  if (br.signature==MBR_PT_REDSEA) {
@@ -122,6 +127,8 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	      }
 	    }
 	  }
+	  if (Let2BlkDevType(bd->first_drv_let+res)!=bd->type)
+	    break;
 	  if (j<0)
 	    break;
 	  if (!mbr.p[j].offset)
@@ -138,7 +145,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
       dv->dv_signature=DRV_SIGNATURE_VAL;
       res++;
       dv->fs_type=FSt_ISO9660; //Start with this
-      dv->size =0;
+      dv->size=0;
       break;
   }
   if (res)
@@ -220,5 +227,4 @@ U0 BlkDevsInitAll()
     StreamDoc(kernel_cfg->add_dev);
     StreamPrint("#exe {Option(OPTf_WARN_PAREN,ON);}");
   };
-  DrvRep;
 }

Kernel/BlkDev/DskBlk.CPP

@@ -37,10 +37,9 @@ Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
   try {
     unlock=DrvLock(dv);
     BlkDevInit(bd);
-    if (dv->base_offset && blk<dv->base_offset ||
-	  blk+cnt>dv->base_offset+dv->size)
+    if (dv->drv_offset && blk<dv->drv_offset ||
+	  blk+cnt>dv->drv_offset+dv->size)
       throw('Drv');
-
     if (bd->flags & BDF_READ_CACHE)
       RCache(dv,&buf,&blk,&cnt);
     if (cnt>0) {
@@ -48,6 +47,9 @@ Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
 	case BDT_RAM:
 	  MemCpy(buf,bd->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
 	  break;
+	case BDT_FILE:
+	  FRBlks(bd->file_dsk,buf,blk,cnt);
+	  break;
 	case BDT_ATA:
 	case BDT_ATAPI:
 	  res=ATARBlks(dv,buf,blk,cnt);
@@ -76,14 +78,17 @@ Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
     BlkDevInit(bd);
     if (bd->flags&BDF_READ_ONLY && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
       throw('BlkDev');
-    if (dv->base_offset && blk<dv->base_offset ||
-	  blk+cnt>dv->base_offset+dv->size)
+    if (dv->drv_offset && blk<dv->drv_offset ||
+	  blk+cnt>dv->drv_offset+dv->size)
       throw('Drv');
     if (cnt>0) {
       switch (bd->type) {
 	case BDT_RAM:
 	  MemCpy(bd->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
 	  break;
+	case BDT_FILE:
+	  FWBlks(bd->file_dsk,buf,blk,cnt);
+	  break;
 	case BDT_ATA:
 	case BDT_ATAPI:
 	  res=ATAWBlks(dv,buf,blk,cnt);

Kernel/BlkDev/DskBlkDev.CPP

@@ -30,19 +30,39 @@ Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE)
 
 Bool BlkDevInit(CBlkDev *bd)
 {
+  CDirEntry de;
+  U8 buf[STR_LEN];
   CDrv *dv=Let2Drv(bd->first_drv_let);
-  Bool res=FALSE;
+  Bool res=FALSE,invalid=FALSE;
   if (!LBts(&bd->flags,BDf_INITIALIZED)) {
     bd->flags|=BDF_INIT_IN_PROGRESS;
     switch (bd->type) {
-      case BDT_RAM:
-	if (!bd->RAM_dsk) {
-	  bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
-	  bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
-	}
+      start:
+	case BDT_RAM:
+	  if (!bd->RAM_dsk) {
+	    bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
+	    bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
+	  }
+	  break;
+	case BDT_FILE:
+	  if (!bd->file_dsk_name) {
+	    StrPrint(buf,"%C:/Drv%C.DRV.C",
+		  blkdev.boot_drv_let,bd->first_drv_let);
+	    bd->file_dsk_name=AStrNew(buf);
+	  }
+	  if (FileFind(bd->file_dsk_name,&de,FUF_JUST_FILES))
+	    bd->max_blk=de.size>>BLK_SIZE_BITS-1;
+	  else {
+	    invalid=TRUE;
+	    if (bd->max_blk<7)
+	      bd->max_blk=7;
+	  }
+	  bd->file_dsk=FOpen(bd->file_dsk_name,"wc+",bd->max_blk+1);
+	  break;
+      end:
 	dv->fs_type=FSt_REDSEA;
-	dv->size=bd->max_blk+1;
-	if (RedSeaDrvValidate(bd->first_drv_let))
+	dv->size=bd->max_blk+1-bd->drv_offset;
+	if (!invalid && RedSeaDrvValidate(bd->first_drv_let))
 	  RedSeaDrvInit(dv);
 	else
 	  RedSeaFmt(bd->first_drv_let);
@@ -89,6 +109,8 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
 {//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
   I64 i=0;
   CBlkDev *res;
+  if (Let2BlkDevType(first_drv_let)!=type)
+    throw('BlkDev');
   do {
     res=&blkdev.blkdevs[i];
     if (res->bd_signature!=BD_SIGNATURE_VAL) {
@@ -116,6 +138,14 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
   return NULL; //never gets here
 }
 
+U0 BlkDevDel(CBlkDev *bd)
+{//Delete BlkDev
+  FClose(bd->file_dsk);
+  Free(bd->file_dsk_name);
+  Free(bd->dev_id_record);
+  MemSet(bd,0,sizeof(CBlkDev));
+}
+
 CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE)
 {//Check for valid BlkDev. Throw exception.
   if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||

Kernel/BlkDev/DskCDDVD.CPP

@@ -1,7 +1,75 @@
+//ISO1 is ISO9660
+//ISO2 is ISO13490
+//ISO3 is ISO13346
+
+Bool ISODrvInit(CDrv *dv,I64 blk)
+{
+  CBlkDev *bd=dv->bd;
+  I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc,drv_offset=0;
+  CISO1PriDesc *iso=MAlloc(bd->blk_size);
+  CISO1DirEntry *de;
+  Bool unlock,res=FALSE;
+  U8 buf[8];
+
+  try {
+    unlock=DrvLock(dv);
+    dv->fs_type=FSt_ISO9660; //default
+    dv->spc=spc;
+    dv->drv_offset=bd->drv_offset=dv->data_area=dv->root_cluster=dv->size=0;
+    while (TRUE) {
+      dv->size=MaxI64(dv->size,(i+1)*spc);
+      RBlks(dv,iso,i*spc,spc);
+      buf[0](U32)=iso->id[0](U32);
+      buf[4](U16)=iso->id[4](U8);
+      switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
+	    LMF_EXACT)) {
+	case 0:
+	  switch (iso->type) {
+	    case ISO1T_BOOT_RECORD:
+	      drv_offset+=(2*DVD_BLK_SIZE+DVD_BLK_SIZE)/BLK_SIZE;
+	      break;
+	    case ISO1T_SUPPLEMENTARY_DESC:
+	      de=&iso->root_dir_record;
+	      dv->root_cluster=de->loc.little;
+	      dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
+	      if (!StrCmp(iso->publisher_id,"TempleOS RedSea")) {
+		dv->fs_type=FSt_REDSEA;
+		bd->drv_offset=dv->drv_offset=19<<2+drv_offset;
+		bd->max_blk=dv->size-1;
+		dv->size-=bd->drv_offset;
+		RedSeaDrvInit(dv);
+	      }
+	      res=TRUE;
+	      goto ipi_done;
+	    case ISO1T_TERMINATOR:
+	      throw('Drv');
+	  }
+	  break;
+	default: //Its normal for ISO13346 to read NULL blk as terminator
+	  PrintErr("File System Not Supported\n");
+	  throw('Drv');
+      }
+      i++;
+    }
+ipi_done:
+    Free(iso);
+    if (unlock)
+      DrvUnlock(dv);
+  } catch {
+    dv->fs_type=FSt_ISO9660;
+    dv->spc=spc;
+    dv->drv_offset=bd->drv_offset=dv->data_area=dv->root_cluster=0;
+    Free(iso);
+    if (unlock)
+      DrvUnlock(dv);
+  }
+  return res;
+}
+
 U0 DVDImageRead(U8 dvd_drv_let,U8 *out_name)
 {//Read entire CD/DVD image into ISO file.
-  CBlkDev *bd=Let2BlkDev(dvd_drv_let);
   CDrv *dv=Let2Drv(dvd_drv_let);
+  CBlkDev *bd=dv->bd;
   U8 *buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS),
 	*out_name2=DftExt(out_name,"ISO");
   CFile *f=FOpen(out_name2,"w");

Kernel/BlkDev/DskCFile.CPP

@@ -55,8 +55,7 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
 	f->flags&=~FF_NEW_FILE;
       }
       DirContextDel(dirc);
-      if (!contiguous || cnt>0)
-	return f;
+      return f;
     }
   } else {
     if (FileFind(full_name,&f->de,FUF_JUST_FILES)) {

Kernel/BlkDev/DskDirA.CPP

@@ -160,9 +160,9 @@ CDirEntry *DirFilesFlatten(CDirEntry *tempde,CDirEntry **_res,I64 fuf_flags)
   return _res;
 }
 
-U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
+U0 PutFileLink(U8 *filename,U8 *full_name=NULL,I64 line=0,Bool plain_text=FALSE)
 {//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ file,line link to StdOut, $LK,"DocPut",A="MN:DocPut"$.
-  U8 *buf;
+  U8 *st;
   if (!filename) return;
   if (IsRaw) {
     if (line)
@@ -177,32 +177,38 @@ U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
       else
 	"$$LK,\"%s\",A=\"AI:%s\"$$",filename+3,filename+3;
     } else {
-      buf=FileNameAbs(filename);
+      if (!full_name)
+	full_name=st=FileNameAbs(filename);
+      else
+	st=NULL;
       if (plain_text) {
 	if (line)
-	  "$$LK,\"%s,%04d\",A=\"PL:%s,%d\"$$",filename,line,buf,line;
+	  "$$LK,\"%s,%04d\",A=\"PL:%s,%d\"$$",filename,line,full_name,line;
 	else
-	  "$$LK,\"%s\",A=\"PI:%s\"$$",filename,buf;
+	  "$$LK,\"%s\",A=\"PI:%s\"$$",filename,full_name;
       } else {
 	if (line)
-	  "$$LK,\"%s,%04d\",A=\"FL:%s,%d\"$$",filename,line,buf,line;
+	  "$$LK,\"%s,%04d\",A=\"FL:%s,%d\"$$",filename,line,full_name,line;
 	else
-	  "$$LK,\"%s\",A=\"FI:%s\"$$",filename,buf;
+	  "$$LK,\"%s\",A=\"FI:%s\"$$",filename,full_name;
       }
-      Free(buf);
+      Free(st);
     }
   }
 }
 
-U0 PutDirLink(U8 *dirname)
+U0 PutDirLink(U8 *dirname,U8 *full_name=NULL)
 {//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ dir macro to StdOut, $LK,"DocPut",A="MN:DocPut"$.
-  U8 *buf;
+  U8 *st;
   if (!dirname) return;
   if (IsRaw)
     "%s",dirname;
   else {
-    buf=DirNameAbs(dirname);
-    "$$MA,T=\"%s\",LM=\"Cd(\\\"%s\\\");Dir;\n\"$$",dirname,buf;
-    Free(buf);
+    if (!full_name)
+      full_name=st=DirNameAbs(dirname);
+    else
+      st=NULL;
+    "$$MA,T=\"%s\",LM=\"Cd(\\\"%s\\\");Dir;\n\"$$",dirname,full_name;
+    Free(st);
   }
 }

Kernel/BlkDev/DskDirB.CPP

@@ -1,3 +1,11 @@
+U0 HomeSet(U8 *dirname)
+{//Change home directory.
+  dirname=DirNameAbs(dirname);
+  Free(blkdev.home_dir);
+  blkdev.home_dir=AStrNew(dirname);
+  Free(dirname);
+}
+
 Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
 {//Change directory. Optionally, make directories, too.
   I64 maxlen,cur_dir_cluster=0;
@@ -5,7 +13,7 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
   CDrv *dv;
   Bool res=TRUE;
   if (!dirname)
-    dirname="::/Home";
+    dirname="~";
   else if (!*dirname)
     return TRUE;
   if (dirname[1]==':') {
@@ -36,6 +44,12 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
       StrLastRem(new_cur_dir,"/");
       if (!*new_cur_dir)
 	StrCpy(new_cur_dir,"/");
+    } else if (!StrCmp(buf,"~")) {
+      Free(new_cur_dir);
+      new_cur_dir=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(chg_to_buf)+1);
+      StrCpy(new_cur_dir,blkdev.home_dir+2);
+      if (Fs->cur_dv!=Let2Drv('~') && !Drv('~'))
+	return FALSE;
     } else if (StrCmp(buf,".") && *buf) {
       dv=Fs->cur_dv;
       cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
@@ -99,6 +113,11 @@ I64 Dir(U8 *files_find_mask,Bool full)
     PrintErr("Invalid Drive\n");
   else {
     if (tempde1) {
+      Free(st);
+      st=MAllocIdent(tempde1->full_name);
+      StrLastRem(st,"/");
+      if (!st[2])
+	StrCpy(st+2,"/");
 //Find max columns
       tempde2=tempde1;
       while (tempde2) {
@@ -129,9 +148,9 @@ I64 Dir(U8 *files_find_mask,Bool full)
 		csize,tempde1->size;
 	}
 	if (tempde1->attr & RS_ATTR_DIR)
-	  PutDirLink(tempde1->name);
+	  PutDirLink(tempde1->name,tempde1->full_name);
 	else
-	  PutFileLink(tempde1->name);
+	  PutFileLink(tempde1->name,tempde1->full_name);
 	'\n';
 	DirEntryDel(tempde1);
 	tempde1=tempde2;
@@ -143,8 +162,9 @@ I64 Dir(U8 *files_find_mask,Bool full)
   return res;
 }
 
-Bool MkDir(U8 *filename)
+Bool MkDir(U8 *filename,I64 entry_cnt=0)
 {//Make directory. $LK,"Cd",A="MN:Cd"$() can also make directories.
+//entry_cnt is for preallocating dir blks, leave it zero if you like.
   U8 *name;
   CDirContext *dirc;
   Bool res=FALSE;
@@ -160,10 +180,10 @@ Bool MkDir(U8 *filename)
 	      SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
 	switch (dirc->dv->fs_type) {
 	  case FSt_REDSEA:
-	    res=RedSeaMkDir(dirc->dv,Fs->cur_dir,name);
+	    res=RedSeaMkDir(dirc->dv,Fs->cur_dir,name,entry_cnt);
 	    break;
 	  case FSt_FAT32:
-	    res=FAT32MkDir(dirc->dv,Fs->cur_dir,name);
+	    res=FAT32MkDir(dirc->dv,Fs->cur_dir,name,entry_cnt);
 	    break;
 	  case FSt_ISO9660:
 	    PrintErr("Not Writable\n");

Kernel/BlkDev/DskDirContext.CPP

@@ -34,6 +34,8 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
       valid=FALSE;
     mask+=2;
   }
+  if (*mask=='~' && Fs->cur_dv!=Let2Drv('~') && !Drv('~'))
+    valid=FALSE;
   dirc->dv=Fs->cur_dv;
   DrvChk(dirc->dv);
   buf=MAlloc(mask_len+2);

Kernel/BlkDev/DskDrv.CPP

@@ -62,6 +62,15 @@ CDrv *DrvNextFree(U8 first_drv_let='C')
   return NULL; //never gets here
 }
 
+U0 DrvDel(CDrv *dv)
+{//Delete drv
+  if (dv->fs_type==FSt_REDSEA && dv->next_free)
+    RedSeaFreeFreeLst(dv);
+  Free(dv->cur_fat_blk);
+  Free(dv->fis);
+  MemSet(dv,0,sizeof(CDrv));
+}
+
 U0 DrvFATBlkAlloc(CDrv *dv)
 {
   DrvChk(dv);
@@ -72,7 +81,7 @@ U0 DrvFATBlkAlloc(CDrv *dv)
   RBlks(dv,dv->cur_fat_blk,dv->fat1,1);
 }
 
-U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
+U0 DrvFATBlkClean(CDrv *dv,I64 fat_sel=3)
 {
   if ((dv->fs_type==FSt_FAT32 || dv->fs_type==FSt_REDSEA) &&
        Bt(&dv->fat_blk_dirty,0)) {
@@ -80,9 +89,9 @@ U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
       WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
       LBtr(&dv->fat_blk_dirty,0);
     } else {
-      if (fat_select==3 || !fat_select)
+      if (fat_sel==3 || !fat_sel)
 	WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
-      if (fat_select==3 || fat_select==1) {
+      if (fat_sel==3 || fat_sel==1) {
 	WBlks(dv,dv->cur_fat_blk,dv->fat2+dv->cur_fat_blk_num,1);
 	LBtr(&dv->fat_blk_dirty,0);
       }
@@ -90,7 +99,7 @@ U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
   }
 }
 
-U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
+U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_sel=3)
 {
   I64 fat_blk_num;
   if (c==INVALID_CLUSTER)
@@ -106,9 +115,9 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
       throw('Drv');
   }
   if (fat_blk_num!=dv->cur_fat_blk_num) {
-    DrvFATBlkClean(dv,fat_select);
+    DrvFATBlkClean(dv,fat_sel);
     dv->cur_fat_blk_num=fat_blk_num;
-    if (fat_select==3 || !fat_select)
+    if (fat_sel==3 || !fat_sel)
       RBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
     else
       RBlks(dv,dv->cur_fat_blk,dv->fat2+dv->cur_fat_blk_num,1);
@@ -139,8 +148,10 @@ I64 Let2BlkDevType(U8 drv_let)
   drv_let=ToUpper(drv_let);
   if ('A'<=drv_let<='B')
     return BDT_RAM;
-  if ('C'<=drv_let<='S')
+  if ('C'<=drv_let<='L')
     return BDT_ATA;
+  if ('M'<=drv_let<='S')
+    return BDT_FILE;
   if ('T'<=drv_let<='Z')
     return BDT_ATAPI;
   return BDT_NULL;
@@ -154,6 +165,8 @@ CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE)
   else {
     if (drv_let==':')
       drv_let=blkdev.boot_drv_let;
+    else if (drv_let=='~')
+      drv_let=*blkdev.home_dir;
     drv_let=ToUpper(drv_let);
     if (!('A'<=drv_let<='Z')) {
       if (except)
@@ -188,7 +201,7 @@ U0 DskCacheInvalidate(CDrv *dv)
     BlkDevInit(bd);
     if (bd->flags & BDF_READ_CACHE)
       DskCacheInvalidate2(dv);
-    if (dv->fs_type==FSt_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
+    if (bd->type==BDT_ATAPI && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
       ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
     if (unlock)
       DrvUnlock(dv);
@@ -228,7 +241,7 @@ Bool Drv(U8 drv_let)
   if (dv!=Fs->cur_dv) {
     if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
       ChgDsk(Drv2Let(dv));
-    if (bd->type==BDT_RAM)
+    if (bd->type==BDT_RAM || bd->type=BDT_FILE)
       BlkDevInit(bd);
   }
   Fs->cur_dv=dv;
@@ -275,7 +288,7 @@ U8 *DrvModelNum(U8 drv_let=0)
   return res;
 }
 
-U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTBLUE};
+U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTGREEN,LTBLUE};
 U8 drv_text_attr[3]={BLACK,BLUE,RED};
 
 U8 DrvTextAttrGet(U8 drv_let=0)
@@ -284,6 +297,8 @@ U8 DrvTextAttrGet(U8 drv_let=0)
     drv_let=Drv2Let(Fs->cur_dv);
   else if (drv_let==':')
     drv_let=blkdev.boot_drv_let;
+  else if (drv_let=='~')
+    drv_let=*blkdev.home_dir;
   drv_let=ToUpper(drv_let);
   if ('A'<=drv_let<='Z')
     return blkdev_text_attr[Let2BlkDevType(drv_let)]<<4|
@@ -298,7 +313,7 @@ U0 DrvRep()
   CBlkDev *bd;
   I64 ch,i,drv_let,attr;
   U8 *st;
-  "\nDefined Drives:\n\n";
+  "\nDefined Drives:\n";
   for (i=0,dv=blkdev.drvs;i<NUM_DRVS;i++,dv++) {
     if (dv->dv_signature==DRV_SIGNATURE_VAL) {
       bd=dv->bd;
@@ -321,9 +336,8 @@ U0 DrvRep()
 	"   Serial#:%s\n",st;
 	Free(st);
       }
-      "   %016X-%016X\n$$FG$$$$BG$$",
-	    dv->base_offset,dv->base_offset+dv->size-1;
-      dv->base_offset,dv->base_offset+dv->size-1;
+      "   %016X-%016X\n$$FG$$$$BG$$",dv->drv_offset,dv->drv_offset+dv->size-1;
     }
   }
+  "Home Dir:\"%s\"\n",blkdev.home_dir;
 }

Kernel/BlkDev/DskFile.CPP

@@ -23,16 +23,13 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
       if (dirc=DirContextNew(curname)) {
 	switch (dirc->dv->fs_type) {
 	  case FSt_REDSEA:
-	    res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  case FSt_FAT32:
-	    res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  case FSt_ISO9660:
-	    res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  default:
 	    PrintErr("File System Not Supported\n");
@@ -52,16 +49,13 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
 	  Cd("..");
 	  switch (Fs->cur_dv->fs_type) {
 	    case FSt_REDSEA:
-	      res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    case FSt_FAT32:
-	      res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    case FSt_ISO9660:
-	      res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    default:
 	      PrintErr("File System Not Supported\n");
@@ -75,8 +69,7 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
       PrintErr("File not found.\n");
     }
     if (res && attr & RS_ATTR_RESIDENT)
-      HashGenericAdd(curname,HTT_FILE,
-	    AMAllocIdent(res),size,0,adam_task);
+      HashGenericAdd(curname,HTT_FILE,AMAllocIdent(res),size,0,adam_task);
   }
   if (res && attr & RS_ATTR_COMPRESSED) {
     arc=res;
@@ -108,12 +101,10 @@ I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0)
     if (!cdt) cdt=Now;
     switch (dirc->dv->fs_type) {
       case FSt_REDSEA:
-	c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
-	      size,cdt,attr);
+	c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,size,cdt,attr);
 	break;
       case FSt_FAT32:
-	c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
-	      size,cdt,attr);
+	c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,size,cdt,attr);
 	break;
       case FSt_ISO9660:
 	PrintErr("Not Writable\n");

Kernel/BlkDev/DskFmt.CPP

@@ -65,6 +65,17 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
     return;
   }
   switch (type) {
+    case FSt_FAT32:
+      if (dv->bd->type==BDT_ATA) {
+	Silent;
+	Drv(drv_let);
+	Silent(old_silent);
+	FAT32Fmt(drv_let,quick);
+	DskCacheInvalidate(Let2Drv(drv_let));
+	Drv(drv_let);
+	break;
+      }
+      "Using RedSea File System.\n";
     case FSt_REDSEA:
       Silent;
       Drv(drv_let);
@@ -73,14 +84,6 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
       DskCacheInvalidate(Let2Drv(drv_let));
       Drv(drv_let);
       break;
-    case FSt_FAT32:
-      Silent;
-      Drv(drv_let);
-      Silent(old_silent);
-      FAT32Fmt(drv_let,quick);
-      DskCacheInvalidate(Let2Drv(drv_let));
-      Drv(drv_let);
-      break;
     case FSt_ISO9660:
       PrintErr("Not Writable\n");
       break;

Kernel/BlkDev/DskStrA.CPP

@@ -60,7 +60,7 @@ Bool FilesFindMatch(U8 *_test_name,U8 *files_find_mask,I64 fuf_flags=0)
     else
       ptr=test_name2;
     if (*mask2) {
-      if (*mask2=='~') {
+      if (*mask2=='!') {
 	if (WildMatch(ptr,mask2+1)) {
 	  res=FALSE;
 	  break;
@@ -115,6 +115,8 @@ U8 *DirNameAbs(U8 *_dirname)
   if (*dirname && dirname[1]==':') {
     if (*dirname==':')
       *drv=blkdev.boot_drv_let;
+    else if (*dirname=='~')
+      *drv=*blkdev.home_dir;
     else
       *drv=*dirname;
     dirname=dirname+2;
@@ -139,9 +141,13 @@ U8 *DirNameAbs(U8 *_dirname)
       StrLastRem(buf3,"/");
       if (!*buf3)
 	StrCpy(buf3,"/");
-    } else if (!StrCmp(buf4,".")) {
-      ;
-    } else if (*buf4) {
+    } else if (!StrCmp(buf4,"~")) {
+      Free(buf3);
+      buf3=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(buf2)+1);
+      StrCpy(buf3,blkdev.home_dir+2);
+      *drv=*blkdev.home_dir;
+    } else if (!StrCmp(buf4,"."));
+    else if (*buf4) {
       if (StrCmp(buf3,"/"))
 	CatPrint(buf3,"/");
       CatPrint(buf3,buf4);
@@ -265,7 +271,7 @@ U8 *ToggleZorNotZ(U8 *name)
 
 U8 *FileNameTempTxt()
 {//Make pretty-safe temp filename in home dir.
-  return MStrPrint("::/Home/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
+  return MStrPrint("~/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
 }
 
 U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL)

Kernel/BlkDev/FileSysFAT.CPP

@@ -26,9 +26,9 @@ U0 FAT32DrvInit(CDrv *dv)
   try {
     unlock=DrvLock(dv);
     dv->fs_type=FSt_FAT32;
-    RBlks(dv,&br32,dv->base_offset,1);
-    dv->file_system_info_sect=dv->base_offset+br32.file_system_info_sect;
-    dv->fat1=dv->base_offset+br32.reserved_sects;
+    RBlks(dv,&br32,dv->drv_offset,1);
+    dv->file_system_info_sect=dv->drv_offset+br32.file_system_info_sect;
+    dv->fat1=dv->drv_offset+br32.reserved_sects;
     dv->fat2=dv->fat1+br32.sects_per_fat;
     dv->data_area=dv->fat2+br32.sects_per_fat
 	  -2*br32.sects_per_cluster; //Starts at Cluster 2
@@ -50,7 +50,7 @@ Bool FAT32DrvValidate(U8 drv_let)
   CDrv *dv;
   CFAT32Boot br;
   if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_FAT32 &&
-	RBlks(dv,&br,dv->base_offset,1) && br.signature==0xAA55 &&
+	RBlks(dv,&br,dv->drv_offset,1) && br.signature==0xAA55 &&
 	br.sects==dv->size)
     return TRUE;
   else
@@ -111,14 +111,14 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
       i=br->reserved_sects+2*l+4*br->sects_per_cluster;
     else
       i=dv->size;
-    WZeroBlks(dv,dv->base_offset,i);
+    WZeroBlks(dv,dv->drv_offset,i);
 
-    WBlks(dv,fis,dv->base_offset+br->file_system_info_sect,1);
-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,fis,dv->drv_offset+br->file_system_info_sect,1);
+    WBlks(dv,br,dv->drv_offset,1);
     FAT32DrvInit(dv);
     ClustersAlloc(dv,0,1,FALSE); //Alloc #1
     br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,br,dv->drv_offset,1);
     FAT32DrvInit(dv);
     DrvUnlock(dv);
   } catch
@@ -462,7 +462,7 @@ I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt)
   try {
     unlock_break=BreakLock;
     unlock=DrvLock(dv);
-    l=(dv->size+dv->base_offset-dv->data_area)/dv->spc-1;
+    l=(dv->size+dv->drv_offset-dv->data_area)/dv->spc-1;
     j=dv->fis->most_recently_alloced;
     while (cnt-->0) {
       while (TRUE) {
@@ -525,7 +525,7 @@ I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
       i=0;
       cont=TRUE;
       while (cont && i<cnt) {
-	if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->base_offset)
+	if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->drv_offset)
 	  throw('Drv');
 	DrvFATBlkSet(dv,first+i);
 	if (dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)])
@@ -930,10 +930,11 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,
   return res;
 }
 
-Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
+Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
 {
-  I64 size=dv->spc<<BLK_SIZE_BITS,c,
-	cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+  I64 c,cur_dir_cluster=Name2DirCluster(dv,cur_dir),
+//Rough estimate of size
+	size=CeilU64((entry_cnt+2)<<FAT32_ENTRIES_BITS,dv->spc<<BLK_SIZE_BITS);
   U8 *buf=CAlloc(size);
   CDirEntry d_native;
   CFAT32DirEntry *dFAT=buf;

Kernel/BlkDev/FileSysISO.CPP

@@ -1,63 +1,3 @@
-//ISO1 is ISO9660
-//ISO2 is ISO13490
-//ISO3 is ISO13346
-
-Bool ISODrvInit(CDrv *dv,I64 blk)
-{
-  CBlkDev *bd=dv->bd;
-  I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc;
-  CISO1PriDesc *iso=MAlloc(bd->blk_size);
-  CISO1DirEntry *de;
-  Bool unlock,res=FALSE;
-  U8 buf[8];
-
-  try {
-    unlock=DrvLock(dv);
-    dv->fs_type=FSt_ISO9660; //default
-    dv->spc=spc;
-    dv->base_offset=dv->data_area=dv->root_cluster=dv->size=0;
-    while (TRUE) {
-      dv->size=MaxI64(dv->size,(i+1)*spc);
-      RBlks(dv,iso,i*spc,spc);
-      buf[0](U32)=iso->id[0](U32);
-      buf[4](U16)=iso->id[4](U8);
-      switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
-	    LMF_EXACT)) {
-	case 0:
-	  dv->fs_type=FSt_ISO9660;
-	  switch (iso->type) {
-	    case ISO1T_SUPPLEMENTARY_DESC:
-	      dv->data_area=0;
-	      de=&iso->root_dir_record;
-	      dv->root_cluster=de->loc.little;
-	      dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
-	      res=TRUE;
-	      goto ipi_done;
-	    case ISO1T_TERMINATOR:
-	      throw('Drv');
-	  }
-	  break;
-	default: //Its normal for ISO13346 to read NULL blk as terminator
-	  PrintErr("File System Not Supported\n");
-	  throw('Drv');
-      }
-      i++;
-    }
-ipi_done:
-    Free(iso);
-    if (unlock)
-      DrvUnlock(dv);
-  } catch {
-    dv->fs_type=FSt_ISO9660;
-    dv->spc=spc;
-    dv->base_offset=dv->data_area=dv->root_cluster=0;
-    Free(iso);
-    if (unlock)
-      DrvUnlock(dv);
-  }
-  return res;
-}
-
 U0 Date2ISO1(CISO1Date *dst,CDate cdt)
 {
   CDateStruct ds;

Kernel/BlkDev/FileSysRedSea.CPP

@@ -25,7 +25,7 @@ U0 RedSeaFreeLstBuild(CDrv *dv)
 {
   Bool unlock;
   CFreeLst *tempf;
-  I64 i,first=dv->data_area,max_blk=dv->size+dv->base_offset;
+  I64 i,first=dv->data_area,max_blk=dv->size+dv->drv_offset;
   try {
     unlock=DrvLock(dv);
     if (dv->next_free)
@@ -61,16 +61,16 @@ U0 RedSeaDrvInit(CDrv *dv)
   Bool unlock;
   try {
     unlock=DrvLock(dv);
-    RBlks(dv,&br,dv->base_offset,1);
+    RBlks(dv,&br,dv->drv_offset,1);
     if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
       throw('Drv');
     dv->fs_type=FSt_REDSEA;
     RedSeaFreeFreeLst(dv);
     dv->spc=1;
     dv->size=br.sects;
-    dv->data_area=dv->base_offset+br.bitmap_sects;
+    dv->data_area=dv->drv_offset+br.bitmap_sects;
     dv->root_cluster=br.root_cluster;
-    dv->fat1=dv->fat2=dv->base_offset+1;
+    dv->fat1=dv->fat2=dv->drv_offset+1;
     DrvFATBlkAlloc(dv);
     if (unlock)
       DrvUnlock(dv);
@@ -84,7 +84,7 @@ Bool RedSeaDrvValidate(U8 drv_let)
   CDrv *dv;
   CRedSeaBoot br;
   if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA &&
-	RBlks(dv,&br,dv->base_offset,1) && br.signature==MBR_PT_REDSEA &&
+	RBlks(dv,&br,dv->drv_offset,1) && br.signature==MBR_PT_REDSEA &&
 	br.signature2==0xAA55 && br.sects==dv->size)
     return TRUE;
   else
@@ -97,7 +97,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
   CDirEntry *d_native;
   CRedSeaBoot *br=CAlloc(BLK_SIZE);
   CDrv *dv=Let2Drv(drv_let);
-  I64 i,n;
+  I64 i,n,root_dir_blks;
   try {
     DrvLock(dv);
 //	DrvTypeSet(drv_let,FSt_REDSEA);
@@ -105,7 +105,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     dv->fs_type=FSt_REDSEA;
     br->signature=MBR_PT_REDSEA;
     br->signature2=0xAA55;
-    br->base_offset=dv->base_offset; //For CD/DVD image copy.
+    br->drv_offset=dv->drv_offset; //For CD/DVD image copy.
     br->sects=dv->size;
     n=(br->sects+BLK_SIZE<<3-1)/BLK_SIZE<<3;
     br->bitmap_sects=n;
@@ -116,21 +116,23 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
       i=n+1;
     else
       i=dv->size;
-    WZeroBlks(dv,dv->base_offset,i);
+    WZeroBlks(dv,dv->drv_offset,i);
 
-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,br,dv->drv_offset,1);
     RedSeaDrvInit(dv);
     ClustersAlloc(dv,0,1,FALSE);	//Alloc #1
-    br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
-    WBlks(dv,br,dv->base_offset,1);
-    root_dir=CAlloc(BLK_SIZE);
+
+    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);
+    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->size=BLK_SIZE;
+    d_native->size=BLK_SIZE*root_dir_blks;
     d_native->datetime=Now;
 
     d_native(U8 *)+=CDIR_SIZE;
@@ -141,7 +143,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
     d_native->cluster=br->root_cluster;
     d_native->datetime=Now;
 
-    WBlks(dv,root_dir,br->root_cluster,1);
+    WBlks(dv,root_dir,br->root_cluster,root_dir_blks);
     RedSeaDrvInit(dv);
     DrvUnlock(dv);
   } catch
@@ -389,9 +391,9 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
 	  WBlks(dv,buf,c,dir_size>>BLK_SIZE_BITS);
 	  if (cur_dir_cluster==dv->root_cluster) {
 	    br=CAlloc(BLK_SIZE);
-	    RBlks(dv,br,dv->base_offset,1);
+	    RBlks(dv,br,dv->drv_offset,1);
 	    br->root_cluster=c;
-	    WBlks(dv,br,dv->base_offset,1);
+	    WBlks(dv,br,dv->drv_offset,1);
 	    Free(br);
 	    dv->root_cluster=c;
 	  } else {
@@ -599,13 +601,14 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
   return res;
 }
 
-Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name)
-{
-  I64 size=BLK_SIZE,c,cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+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),
+	size=CeilU64((entry_cnt+3)<<6,BLK_SIZE);
+#assert CDIR_SIZE==64
   U8 *buf=CAlloc(size);
   CDirEntry *d_native=buf-offset(CDirEntry.start);
   Bool unlock_break;
-
   try {
     unlock_break=BreakLock;
     c=FileWrite(name,buf,size,0,RS_ATTR_DIR);