// See RedSea File System U0 RedSeaFreeFreeLst(CDrv *dv) { CFreeLst *tmpf,*tmpf1; Bool unlock; try { unlock=DrvLock(dv); if (tmpf=dv->next_free) { while (tmpf!=&dv->next_free) { tmpf1=tmpf->next; Free(tmpf); tmpf=tmpf1; } } dv->next_free=NULL; if (unlock) DrvUnlock(dv); } catch if (unlock) DrvUnlock(dv); } U0 RedSeaFreeLstBuild(CDrv *dv) { Bool unlock; CFreeLst *tmpf; I64 i,first=dv->data_area,max_blk=dv->size+dv->drv_offset; try { unlock=DrvLock(dv); if (dv->next_free) RedSeaFreeFreeLst(dv); QueInit(&dv->next_free); while (first<max_blk) { 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))) break; else i++; } if (i) { tmpf=AMAlloc(sizeof(CFreeLst)); tmpf->size=i; tmpf->start=first; QueIns(tmpf,dv->last_free); } first+=i+1; } if (unlock) DrvUnlock(dv); } catch if (unlock) DrvUnlock(dv); } U0 RedSeaInit(CDrv *dv) { CRedSeaBoot br; Bool unlock; try { unlock=DrvLock(dv); BlkRead(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->drv_offset+br.bitmap_sects; dv->root_clus=br.root_clus; dv->fat1=dv->fat2=dv->drv_offset+1; DrvFATBlkAlloc(dv); if (unlock) DrvUnlock(dv); } catch if (unlock) DrvUnlock(dv); } Bool RedSeaValidate(U8 drv_let) { CDrv *dv; CRedSeaBoot br; if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA && BlkRead(dv,&br,dv->drv_offset,1) && br.signature==MBR_PT_REDSEA && br.signature2==0xAA55 && br.sects==dv->size) return TRUE; else return FALSE; } U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE) { U8 *root_dir; CDirEntry *d_native; CRedSeaBoot *br=CAlloc(BLK_SIZE); CDrv *dv=Let2Drv(drv_let); I64 i,n,root_dir_blks; try { DrvLock(dv); // DrvTypeSet(drv_let,FSt_REDSEA); DrvTypeSet(drv_let,FSt_FAT32); dv->fs_type=FSt_REDSEA; br->signature=MBR_PT_REDSEA; br->signature2=0xAA55; 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; br->unique_id=GetTSC^Now()(U64); br->root_clus=0; if (quick) i=n+1; else i=dv->size; BlkZeroWrite(dv,dv->drv_offset,i); BlkWrite(dv,br,dv->drv_offset,1); RedSeaInit(dv); ClusAlloc(dv,0,1,FALSE); //Alloc #1 root_dir_blks=MaxI64(1,dv->bd->init_root_dir_blks); 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->clus=br->root_clus; d_native->size=BLK_SIZE*root_dir_blks; d_native->datetime=Now; d_native(U8 *)+=CDIR_SIZE; *d_native->name='.'; d_native->name[1]='.'; d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS; d_native->clus=br->root_clus; d_native->datetime=Now; BlkWrite(dv,root_dir,br->root_clus,root_dir_blks); RedSeaInit(dv); DrvUnlock(dv); } catch DrvUnlock(dv); Free(br); Free(root_dir); } Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_clus,U8 *name, CDirEntry *_res,I64 fuf_flags=0) {//FUF_JUST_DIRS, FUF_JUST_FILES CDirEntry *buf,*buf2,*ptr; U8 dname[CDIR_FILENAME_LEN]; I64 ch; Bool res=FALSE,unlock; if (fuf_flags&~FUG_FILE_FIND) throw('FUF'); MemSet(_res,0,sizeof(CDirEntry)); DrvChk(dv); if (dv->fs_type!=FSt_REDSEA) PrintErr("Not RedSea Drv\n"); else if (!CFileNameTo(dname,name)) PrintErr("Invalid FileName.\n"); else try { unlock=DrvLock(dv); buf2=MAlloc(BLK_SIZE); BlkRead(dv,buf2,cur_dir_clus,1); ptr=buf2(U8 *)-offset(CDirEntry.start); buf=MAlloc(ptr->size); 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; while (TRUE) { if (!(ch=*ptr->name)) break; else if (!(ptr->attr & RS_ATTR_DELETED) && !(fuf_flags&FUF_JUST_DIRS && !(ptr->attr & RS_ATTR_DIR)) && !(fuf_flags&FUF_JUST_FILES && ptr->attr & RS_ATTR_DIR) && !StrCmp(dname,ptr->name)) { MemCpy(&_res->attr,&ptr->attr,CDIR_SIZE); res=TRUE; goto rsff_done; } ptr(U8 *)+=CDIR_SIZE; } rsff_done: Free(buf); if (unlock) DrvUnlock(dv); } catch if (unlock) DrvUnlock(dv); return res; } U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr) { U8 *buf=NULL; CDirEntry de; I64 c,blk_cnt,cur_dir_clus; DrvChk(dv); *_size=0; *_attr=0; if (dv->fs_type!=FSt_REDSEA) PrintErr("Not RedSea Drv\n"); else try { DrvLock(dv); 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.clus; c=BlkRead(dv,buf,c,blk_cnt); buf[de.size]=0; //Terminate *_size=de.size; *_attr=FileAttr(de.name,de.attr); } DrvUnlock(dv); } catch DrvUnlock(dv); return buf; } 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_clus,name,&de,FUF_JUST_DIRS)) return TRUE; else { "%s ",name; PrintErr("File not found.\n"); } return FALSE; } U0 RedSeaFreeClus(CDrv *dv,I64 c,I64 cnt) { CFreeLst *tmpf; Bool found=FALSE,unlock,unlock_break; DrvChk(dv); if (!c) return; if (dv->fs_type!=FSt_REDSEA) PrintErr("Not RedSea Drv\n"); else try { unlock_break=BreakLock; unlock=DrvLock(dv); if (!dv->next_free) RedSeaFreeLstBuild(dv); tmpf=dv->next_free; while (!found && tmpf!=&dv->next_free) { if (tmpf->start+tmpf->size==c) { tmpf->size+=cnt; found=TRUE; } else if (c+cnt==tmpf->start) { tmpf->size+=cnt; tmpf->start=c; found=TRUE; } tmpf=tmpf->next; } if (!found) { tmpf=AMAlloc(sizeof(CFreeLst)); tmpf->size=cnt; tmpf->start=c; QueIns(tmpf,dv->last_free); } while (cnt-->0) { DrvFATBlkSet(dv,c); LBtr(dv->cur_fat_blk,(c-dv->data_area)&(BLK_SIZE<<3-1)); LBts(&dv->fat_blk_dirty,0); c++; } DrvFATBlkClean(dv); if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } catch { if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } } I64 RedSeaAllocClus(CDrv *dv,I64 cnt) { CFreeLst *tmpf,*best_free=NULL; I64 i,first,best_size=I64_MAX; Bool unlock,unlock_break; if (cnt<=0) throw('Drv'); try { unlock_break=BreakLock; unlock=DrvLock(dv); if (!dv->next_free) RedSeaFreeLstBuild(dv); tmpf=dv->next_free; while (tmpf!=&dv->next_free) { if (tmpf->size>=cnt && tmpf->size<best_size) { best_free=tmpf; best_size=tmpf->size; if (tmpf->size==cnt) break; } tmpf=tmpf->next; } if (!best_free) throw('Drv'); first=best_free->start; for (i=0;i<cnt;i++) { DrvFATBlkSet(dv,first+i); LBts(dv->cur_fat_blk,(first+i-dv->data_area)&(BLK_SIZE<<3-1)); LBts(&dv->fat_blk_dirty,0); } DrvFATBlkClean(dv); if (best_free->size-=cnt) best_free->start+=cnt; else { QueRem(best_free); Free(best_free); } if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } catch { if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } return first; } 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_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_clus=Name2DirClus(dv,cur_dir); buf2=MAlloc(BLK_SIZE); BlkRead(dv,buf2,cur_dir_clus,1); ptr=buf2(U8 *)-offset(CDirEntry.start); buf=MAlloc(ptr->size); BlkRead(dv,buf,cur_dir_clus,ptr->size>>BLK_SIZE_BITS); dir_size=ptr->size; ptr=buf(U8 *)-offset(CDirEntry.start)+CDIR_SIZE; Free(buf2); while (TRUE) { if (!(ch=*ptr->name)) { if (!written) MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE); if ((i+1)*CDIR_SIZE+j<<BLK_SIZE_BITS<dir_size) 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); RedSeaFreeClus(dv,cur_dir_clus,dir_size>>BLK_SIZE_BITS); dir_size+=BLK_SIZE; 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->clus=c; BlkWrite(dv,buf,c,dir_size>>BLK_SIZE_BITS); if (cur_dir_clus==dv->root_clus) { br=CAlloc(BLK_SIZE); BlkRead(dv,br,dv->drv_offset,1); br->root_clus=c; BlkWrite(dv,br,dv->drv_offset,1); Free(br); dv->root_clus=c; } else { tmp=StrNew(cur_dir); parent_dir=StrNew(cur_dir); StrLastRem(parent_dir,"/",tmp); if (!*parent_dir) { Free(parent_dir); parent_dir=StrNew("/"); } if (RedSeaFileFind(dv,Name2DirClus(dv,parent_dir), tmp,&de2,FUF_JUST_DIRS)) { de2.clus=c; de2.size=dir_size; RedSeaDirNew(dv,parent_dir,&de2,FALSE); } else throw('Drv'); Free(tmp); Free(parent_dir); } } break; } else if (ptr->attr & RS_ATTR_DELETED) { if (!written) { MemCpy(&ptr->start,&tmpde->start,CDIR_SIZE); 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) 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; BlkWrite(dv,buf(U8 *)+j<<BLK_SIZE_BITS,cur_dir_clus+j,1); break; } } ptr(U8 *)+=CDIR_SIZE; if (++i>=n) { j++; i=0; } } Free(buf); if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } catch { if (unlock) DrvUnlock(dv); if (unlock_break) BreakUnlock; } return FALSE; } 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_clus; Bool unlock_break; try { unlock_break=BreakLock; DrvLock(dv); cur_dir_clus=Name2DirClus(dv,cur_dir); buf2=MAlloc(BLK_SIZE); BlkRead(dv,buf2,cur_dir_clus,1); ptr=buf2(U8 *)-offset(CDirEntry.start); buf=MAlloc(ptr->size); 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; while (TRUE) { if (!(ch=*ptr->name)) break; else if (!(ptr->attr & RS_ATTR_DELETED) && ch!='.' && (del_dir || !(ptr->attr & RS_ATTR_DIR)) && FilesFindMatch(ptr->name,files_find_mask,fuf_flags)) { if (!(ptr->attr & RS_ATTR_DIR)) res++; if (print_msg) "Del %s\n",ptr->name; ptr->attr|=RS_ATTR_DELETED; 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; if (++i>=n) { j++; i=0; } } Free(buf); DrvUnlock(dv); if (unlock_break) BreakUnlock; } catch { DrvUnlock(dv); if (unlock_break) BreakUnlock; } return res; } I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size, CDate cdt,I64 attr) { CDirEntry de; I64 c=0,blk_cnt; MemSet(&de,0,sizeof(CDirEntry)); if (size<0) size=0; if (dv->fs_type!=FSt_REDSEA) PrintErr("Not RedSea Drv\n"); else if (!CFileNameTo(de.name,name)) PrintErr("Invalid FileName.\n"); else { RedSeaFilesDel(dv,cur_dir,de.name,0,FALSE,FALSE); de.size=size; if (blk_cnt=(size+BLK_SIZE-1)>>BLK_SIZE_BITS) c=ClusAlloc(dv,0,blk_cnt,TRUE); //Always contiguous else c=INVALID_CLUS; de.clus=c; de.attr=attr|RS_ATTR_CONTIGUOUS; de.datetime=cdt; if (blk_cnt) BlkWrite(dv,buf,c,blk_cnt); RedSeaDirNew(dv,cur_dir,&de,TRUE); } return c; } CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags, CDirEntry *parent=NULL) { CDrv *dv=Fs->cur_dv; CDirEntry *buf,*buf2,*ptr,*res=NULL,*tmpde; I64 ch,cur_dir_clus; if (fuf_flags&~FUG_FILES_FIND) throw('FUF'); try { DrvLock(dv); cur_dir_clus=Name2DirClus(dv,Fs->cur_dir); buf2=MAlloc(BLK_SIZE); BlkRead(dv,buf2,cur_dir_clus,1); ptr=buf2(U8 *)-offset(CDirEntry.start); buf=MAlloc(ptr->size); 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->clus=Name2ParentDirClus(dv,Fs->cur_dir); ptr(U8 *)-=CDIR_SIZE; while (TRUE) { if (!(ch=*ptr->name)) break; else if (!(ptr->attr & RS_ATTR_DELETED)) { tmpde=CAlloc(sizeof(CDirEntry)); MemCpy(&tmpde->start,&ptr->start,CDIR_SIZE); tmpde->parent=parent; if (Bt(&fuf_flags,FUf_RECURSE) && tmpde->attr&RS_ATTR_DIR && *tmpde->name!='.') { tmpde->next=res; res=tmpde; tmpde->full_name=DirNameAbs(tmpde->name); DrvUnlock(dv); if (Cd(tmpde->name)) { tmpde->sub=RedSeaFilesFind(files_find_mask,fuf_flags,tmpde); Cd(".."); } DrvLock(dv); } else { tmpde->full_name=FileNameAbs(tmpde->name); if ((tmpde->attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) && !(Bt(&fuf_flags,FUf_RECURSE) && *tmpde->name=='.' && tmpde->attr&RS_ATTR_DIR) && FilesFindMatch(tmpde->full_name,files_find_mask,fuf_flags)) { tmpde->next=res; res=tmpde; } else DirEntryDel(tmpde); } } ptr(U8 *)+=CDIR_SIZE; } Free(buf); DrvUnlock(dv); } catch DrvUnlock(dv); return res; } Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt) {//entry_cnt is for preallocating dir blks. 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); CDirEntry *d_native=buf-offset(CDirEntry.start); Bool unlock_break; try { unlock_break=BreakLock; 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->clus=c; d_native->size=size; d_native->datetime=Now; d_native(U8 *)+=CDIR_SIZE; d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS; *d_native->name='.'; d_native->name[1]='.'; d_native->name[2]=0; d_native->clus=cur_dir_clus; d_native->size=0; d_native->datetime=Now; BlkWrite(dv,buf,c,1); Free(buf); if (unlock_break) BreakUnlock; } catch if (unlock_break) BreakUnlock; return TRUE; }