cfs.cpp

一款运行于ARM上的文件系统

#include "stdafx.h"
#include"cfs.hpp"





///////////////////////////////////////////////////////
//函数名：cfsDBRGet
//功能  ：从存储卷中获取DBR数据
//入参  ：cfs_int8 *pSec   一个扇区的数据缓冲区
//出参  ：cfs_bool	
//                 CFS_TURE   取数据完成  
//                 CFS_FALSE  取数据出错
///////////////////////////////////////////////////////
	cfs_bool    cCFS_DBR::cfsDBRGet(cfs_int8 *pSec)
{
	cfs_int8 i=0;
	if(rom_read_sec(bpbBytsPerSec, CFS_DBR_START_SEC, pSec))
	{
		for(i=0;i<8;i++)
		{
			boOEMName[i] = *(pSec+i);
		}
		bpbBytsPerSec = *(pSec+i) + 0x100 * ((cfs_uint16)(*(pSec+i+1)));
		i+=2;
		bpbRootDirEnts= *(pSec+i) + 0x100 * ((cfs_uint16)(*(pSec+i+1)));
		i+=2;
		bpbTotSec = *(pSec+i) + 0x100 * ((cfs_uint16)(*(pSec+i+1)));
		i+=2;
		bpbFATSec = *(pSec+i) + 0x100 * ((cfs_uint16)(*(pSec+i+1)));
		i+=2;
		ExtMarker1 = *(pSec+i++);
		ExtMarker2 = *(pSec+i);
	}
	else
	{
		return CFS_FALSE;
	}
	return CFS_TURE;
}


///////////////////////////////////////////////////////
//函数名：cfsDBRWrt
//功能  ：将DBR数据存入存储卷中
//入参  ：cfs_int8 *pSec   一个扇区的数据缓冲区
//出参  ：cfs_bool	
//                 CFS_TURE   存储数据完成  
//                 CFS_FALSE  存储数据出错
///////////////////////////////////////////////////////

	cfs_bool    cCFS_DBR::cfsDBRWrt(cfs_int8 *pSec)
{
	cfs_int8 i=0;
	for(;i < 8; i++)
		*(pSec+i)=boOEMName[i];
	*(pSec+i++) = bpbBytsPerSec % 0x100;
	*(pSec+i++) = bpbBytsPerSec / 0x100;
	*(pSec+i++) = bpbRootDirEnts % 0x100;
	*(pSec+i++) = bpbRootDirEnts / 0x100;
	*(pSec+i++) = bpbTotSec % 0x100;
	*(pSec+i++) = bpbTotSec / 0x100;
	*(pSec+i++) = bpbFATSec % 0x100;
	*(pSec+i++) = bpbFATSec / 0x100;
	*(pSec+i++) = ExtMarker1;
	*(pSec+i)   = ExtMarker2;
	if(rom_write_sec(bpbBytsPerSec,CFS_DBR_START_SEC, pSec))
	{
		return CFS_TURE;
	}
	else
	{
		return CFS_FALSE;
	}
}




///////////////////////////////////////////////////////
//函数名：cfsDBRForMat
//功能  ：格式化存储卷中的DBR数据区
//入参  ：cfs_int8 *pSec   一个扇区的数据缓冲区
//出参  ：cfs_bool	
//                 CFS_TURE   格式化数据完成  
//                 CFS_FALSE  格式化数据出错
///////////////////////////////////////////////////////
	cfs_bool    cCFS_DBR::cfsDBRForMat(cfs_int8 *pSec)
{
	cfs_int8 i=0;
	cfs_int8 *p = CFS_OEM_NAME;
	for(;i < 8; i++)
	{
		*(pSec+i)=p[i];
		boOEMName[i]=p[i];
	}
	*(pSec+i++) = CFS_BYTES_PER_SEC % 0x100;
	*(pSec+i++) = CFS_BYTES_PER_SEC / 0x100;
	bpbBytsPerSec = CFS_BYTES_PER_SEC;
	*(pSec+i++) = 0 % 0x100;
	*(pSec+i++) = 0 / 0x100;
	bpbRootDirEnts = 0;
	*(pSec+i++) = ROM_SEC_SIZE % 0x100;
	*(pSec+i++) = ROM_SEC_SIZE / 0x100;
	bpbTotSec =  ROM_SEC_SIZE;
	*(pSec+i++) = CFS_FAT_SEC % 0x100;
	*(pSec+i++) = CFS_FAT_SEC / 0x100;
	bpbFATSec =  CFS_FAT_SEC;
	*(pSec+i++) = CFS_EXT_MARKER1;
	ExtMarker1 = (cfs_uint8)CFS_EXT_MARKER1;
	*(pSec+i)   = CFS_EXT_MARKER2;
	ExtMarker2 = (cfs_uint8)CFS_EXT_MARKER2;
	if(rom_write_sec(CFS_BYTES_PER_SEC, CFS_DBR_START_SEC, pSec))
	{
		return CFS_TURE;
	}
	else
	{
		return CFS_FALSE;
	}
}






///////////////////////////////////////////////////////
//函数名：cfsFATForMat
//功能  ：格式化存储卷中的FAT数据区
//入参  ：void
//出参  ：cfs_bool	
//                 CFS_TURE   格式化数据完成  
//                 CFS_FALSE  格式化数据出错
///////////////////////////////////////////////////////
	cfs_bool	cCFS::cfsFATForMat(void)
{
	cfs_uint16  x=0,i=0;
	pCfsFat[x++] = CFS_FAT_USE_END;
	for(i=1; i <= CFS_FAT_SEC; i++)
	{
		pCfsFat[x++] = CFS_FAT_USE_END;
	}
	for(i= 1 + CFS_FAT_SEC; i < CFS_FAT_SEC + 1 + CFS_ROOTDIR_SEC; i++)
	{
		pCfsFat[x++] = CFS_FAT_USE_END;
	}
	for(i= CFS_FAT_SEC + 1 + CFS_ROOTDIR_SEC; i <  ROM_SEC_SIZE ; i++)
	{
		pCfsFat[x++] = CFS_FAT_NOT_USE;
	}
	return(cfsFATWrt());
}



///////////////////////////////////////////////////////
//函数名：cfsFATGet
//功能  ：读取存储卷中的FAT数据区
//入参  ：void
//出参  ：cfs_bool	
//                 CFS_TURE   写数据完成  
//                 CFS_FALSE  写数据出错
///////////////////////////////////////////////////////
	cfs_bool    cCFS::cfsFATGet(void)
{
	cfs_int32 x=0,y=0,z=0,i=1;
	for(x = CfsDbr.bpbTotSec; x > CfsDbr.bpbBytsPerSec; x -= CfsDbr.bpbBytsPerSec)
	{
		if(rom_read_sec(CfsDbr.bpbBytsPerSec, i++, pCfsSecBuf))
	         return CFS_FALSE;
		for(z = 0; z < CfsDbr.bpbBytsPerSec ; z += 2)
		{
	    	pCfsFat[y] = ((cfs_uint32)(*(pCfsSecBuf + z + 1))) << 8;
	    	pCfsFat[y++] |= (cfs_uint32)(*(pCfsSecBuf + z));
		}
			

	}
	if(!rom_read_sec(CfsDbr.bpbBytsPerSec, i, pCfsSecBuf))
		return CFS_FALSE;
	for(z = 0; z < x; z += 2)
	{
		pCfsFat[y] = ((cfs_uint32)(*(pCfsSecBuf + z + 1))) << 8;
		pCfsFat[y++] |= (cfs_uint32)(*(pCfsSecBuf + z));
	}
	return CFS_TURE;
}



///////////////////////////////////////////////////////
//函数名：cfsFATNextSec
//功能  ：读取FAT数据区中当前扇区指向的下一个扇区的地址
//入参  ：cfs_uint16 currentSec   当前扇区
//出参  ：cfs_uint16 下一个扇区的地址
///////////////////////////////////////////////////////
	cfs_uint16  cCFS::cfsFATNextSec(cfs_uint16 currentSec)
{
		return(pCfsFat[currentSec]);
}




///////////////////////////////////////////////////////
//函数名：cfsFATFindNullSec
//功能  ：查找FAT数据区中的空扇区
//入参  ：void
//出参  ：cfs_uint16 一个空扇区的地址
///////////////////////////////////////////////////////
	cfs_uint16  cCFS::cfsFATFindNullSec(void)
{
	cfs_int32 i=0;
	for(i = CfsDbr.bpbFATSec + 1 + CfsRootDirSec; i < CfsDbr.bpbTotSec; i++)
	{
		if(pCfsFat[i] == CFS_FAT_NOT_USE)
		{
			return(i);
		}
	}
	return (CFS_FAT_USE_END);
}



///////////////////////////////////////////////////////
//函数名：cfsFATCntNullSec
//功能  ：计算FAT数据区中的空扇区的总数目
//入参  ：void
//出参  ：cfs_uint16    空扇区的总数目
///////////////////////////////////////////////////////
	cfs_uint16  cCFS::cfsFATCntNullSec(void)
{
	cfs_int32 i=0,x=0;
	for(i = CfsDbr.bpbFATSec + 1 + CfsRootDirSec; i < CfsDbr.bpbTotSec; i++)
	{
		if(pCfsFat[i] == CFS_FAT_NOT_USE)
		{
			x++;
		}
	}
	return(x);
}

///////////////////////////////////////////////////////
//函数名：cfsFATSetSec
//功能  ：设置FAT数据区中当前扇区指向的下一个扇区的地址
//入参  ：cfs_uint16 currentSec   当前扇区
//      ：cfs_uint16 nextsec      下一个扇区的地址
//出参  ：void

///////////////////////////////////////////////////////
	void    cCFS:: cfsFATSetSec(cfs_uint16 currentsec,cfs_uint16 nextsec)
{
	pCfsFat[currentsec]=nextsec;
}

///////////////////////////////////////////////////////
//函数名：cfsFATWrt
//功能  ：将FAT数据区写入存储卷中
//入参  ：void
//出参  ：cfs_bool	
//                 CFS_TURE   写数据完成  
//                 CFS_FALSE  写数据出错
///////////////////////////////////////////////////////
	cfs_bool    cCFS::cfsFATWrt(void)
{
		cfs_int32 i=0,x=0,y=0,w=0;
		for(i=1; i< CfsDbr.bpbFATSec; i++)
		{
			for(x=0; x < CfsDbr.bpbBytsPerSec; x+=2,y++)
			{
			pCfsSecBuf[x]   = (cfs_uint8)pCfsFat[y] ; 
			pCfsSecBuf[x+1] = (cfs_uint8)(pCfsFat[y] >> 8); 
			}
			if(!rom_write_sec(CfsDbr.bpbBytsPerSec, i,pCfsSecBuf))
			{
				return(CFS_FALSE);
			}
		}
		w=CfsDbr.bpbTotSec * 2;
		while(w > CfsDbr.bpbBytsPerSec){
			w -= CfsDbr.bpbBytsPerSec;
		}
		for(x=0; x < w; x+=2,y++)
		{
			pCfsSecBuf[x]   = (cfs_uint8)pCfsFat[y] ; 
			pCfsSecBuf[x+1] = (cfs_uint8)(pCfsFat[y] >> 8); 
		}
		if(!rom_write_sec(CfsDbr.bpbBytsPerSec, i, pCfsSecBuf))
		{
			return(CFS_FALSE);
		}
		return CFS_TURE;
}




////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////
//函数名：cfsRootDirGetAEntry
//功能  ：从一个扇区的数据缓冲区中取出RootDir根目录的一个文件目录数据
//        使用这一函数前，必须保证扇区数据缓冲区中已经有文件目录数据
//入参  ：cfs_uint16 x       文件目录在扇区数据缓冲区的首地址
//        cCFS_FILEENTRY *p  指向文件目录的指针
//出参  ：void
///////////////////////////////////////////////////////
	void cCFS::cfsRootDirGetAEntry(cfs_uint16 x,cCFS_FILEENTRY *p)
{
	cfs_uint8 i=0;

	for(i=0; i< 8; i++)
	{
		p->fileName[i]=*(pCfsSecBuf + x++);
	}

	for(i=0; i< 3; i++)
	{
		p->fileExtension[i]=*(pCfsSecBuf + x++);
	}

	p->fileAttributes = *(pCfsSecBuf + x++);

	for(i=0; i< 6; i++,x++);

	p->fileCrtTime = *(pCfsSecBuf + x + 1);
	p->fileCrtTime = (p->fileCrtTime << 8) + *(pCfsSecBuf + x);
	x+=2;

	p->fileCrtDate = *(pCfsSecBuf + x + 1);
	p->fileCrtDate = (p->fileCrtDate << 8) + *(pCfsSecBuf + x);
	x+=2;

	p->fileWrtTime = *(pCfsSecBuf + x + 1);
	p->fileWrtTime = (p->fileWrtTime << 8) + *(pCfsSecBuf + x);
	x+=2;

	p->fileWrtDate = *(pCfsSecBuf + x + 1);
	p->fileWrtDate = (p->fileWrtDate << 8) + *(pCfsSecBuf + x);
	x+=2;

	p->fileStartSec = *(pCfsSecBuf + x + 1);
	p->fileStartSec = (p->fileStartSec << 8) + *(pCfsSecBuf + x);
	x+=2;

	p->fileSize = *(pCfsSecBuf + x + 3);
	p->fileSize = (p->fileSize << 8) + *(pCfsSecBuf + x + 2);
	p->fileSize = (p->fileSize << 8) + *(pCfsSecBuf + x + 1);
	p->fileSize = (p->fileSize << 8) + *(pCfsSecBuf + x + 0);
}




///////////////////////////////////////////////////////
//函数名：cfsRootDirWrtAEntry
//功能  ：将RootDir根目录的一个文件目录数据写入存储卷中
//入参  ：cfs_uint32 x   文件句柄
//出参  ：cfs_bool	
//                 CFS_TURE   写数据完成  
//                 CFS_FALSE  写数据出错
///////////////////////////////////////////////////////
	cfs_bool    cCFS::cfsRootDirWrtAEntry(cfs_uint32 x)
{
	cfs_int32 i=0,z=0,y=1,n=0,r=0,q=0;
	cCFS_FILEENTRY p;
	n=CfsDbr.bpbBytsPerSec / CFS_DIR_ENTYR_SIZE;
	z=CfsRootDir.fnCount();
	while(y + n <= x)
	{
		y+=n;	
	}
	for(i=0; i < n; i++,y++)
	{
		if(y <= z)
		{
			p=CfsRootDir.fnGet(y);
			q=0;
            for(r=0; r< 8; r++)
			{
				*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = p.fileName[r];
				q++;
			}
			for(r=0; r< 3; r++)
			{
				*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = p.fileExtension[r];
				q++;
			}
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = p.fileAttributes;
            q++;
			for(r=0; r< 6; r++,q++);
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileCrtTime);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileCrtTime >> 8);
			q++;

			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileCrtDate);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileCrtDate >> 8);
			q++;

			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileWrtTime);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileWrtTime >> 8);
			q++;

			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileWrtDate);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileWrtDate >> 8);
			q++;

			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileStartSec);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileStartSec >> 8);
			q++;

			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileSize);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileSize >> 8);
			q++;
            *(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileSize >> 16);
			q++;
			*(pCfsSecBuf + i*CFS_DIR_ENTYR_SIZE + q) = (cfs_uint8)(p.fileSize >> 24);
		}
		else
			break;
	}
	return(rom_write_sec(CfsDbr.bpbBytsPerSec, 1+ CfsDbr.bpbFATSec + y/n, pCfsSecBuf));
}






///////////////////////////////////////////////////////
//函数名：cfsRootDirRead
//功能  ：从存储卷中取出RootDir根目录的所有文件目录数据
//入参  ：void
//出参  ：cfs_bool	
//                 CFS_TURE   写数据完成  
//                 CFS_FALSE  写数据出错
///////////////////////////////////////////////////////
    cfs_bool    cCFS::cfsRootDirRead(void)
{
	cfs_uint32 dirents=0,dirsec=0,i=0,n=0,z=0;
	cCFS_FILEENTRY p;
	dirsec = (CfsDbr.bpbRootDirEnts * CFS_DIR_ENTYR_SIZE) % CfsDbr.bpbBytsPerSec > 0 ?
		     (CfsDbr.bpbRootDirEnts * CFS_DIR_ENTYR_SIZE) / CfsDbr.bpbBytsPerSec + 1 :
             (CfsDbr.bpbRootDirEnts * CFS_DIR_ENTYR_SIZE) / CfsDbr.bpbBytsPerSec;
    n=CfsDbr.bpbBytsPerSec / CFS_DIR_ENTYR_SIZE;
	for(i=1 ; i < dirsec ; i++)
	{
		if(!rom_read_sec(CfsDbr.bpbBytsPerSec, CfsDbr.bpbFATSec + i, pCfsSecBuf))
		{
			return CFS_FALSE;
		}
		for(z=0; z < n; z++)
		{
			cfsRootDirGetAEntry(z,&p);
			CfsRootDir.fnAddItem(p);
		}
	}
		if(!rom_read_sec(CfsDbr.bpbBytsPerSec, CfsDbr.bpbFATSec + i, pCfsSecBuf))
		{
			return CFS_FALSE;
		}
		for(z=0; z < CfsDbr.bpbRootDirEnts % (CfsDbr.bpbBytsPerSec / CFS_DIR_ENTYR_SIZE); z++)
		{
			cfsRootDirGetAEntry(z,&p);
			CfsRootDir.fnAddItem(p);
		}
	return CFS_TURE;
}






	cfs_bool    cCFS::cfsRootDirWrt(void)
{
    
	return CFS_TURE;
}
///////////////////////////////////////////////////////////////////////////////////

	
	
	
	
	cCFS::cCFS()
{
	pCfsFat = CFS_NULL;
	
}