基于c语言的文件系统FAT16操作源代码(2)

}

//************************************************************************************ //获取数据区开始扇区号 uint32 DataStartSec(void)

//************************************************************************************ {

return (uint32)(DirStartSec() + BPB_RootEntCnt * 32 / BPB_BytesPerSec); }

//************************************************************************************ //目录项占用的扇区数

uint16 GetDirSecCount(void)

//************************************************************************************ {

return BPB_RootEntCnt * 32 / 512; }

//************************************************************************************ //获取一个簇的开始扇区

uint32 ClusConvLBA(uint16 ClusID)

//************************************************************************************* {

return DataStartSec() + BPB_SecPerClus * (ClusID - 2); }

//************************************************************************************* //读取文件分配表的指定项 uint16 ReadFAT(uint16 Index)

//*********************************************************************************** {

uint16 *RAM = (uint16*)BUFFER;

ReadBlock(BPB_RsvdSecCnt + Index / 256); return RAM[Index % 256]; }

//*********************************************************************************** //写文件分配表的指定项

void WriteFAT(uint16 Index, uint16 Value)

//*********************************************************************************** {

uint16 *RAM = (uint16*)BUFFER; uint32 SecID;

SecID = BPB_RsvdSecCnt + Index / 256; ReadBlock(SecID);

RAM[Index % 256] = Value;

6

WriteBlock(SecID); }

//*********************************************************************************** //获取根目录中可以使用的一项 uint16 GetEmptyDIR()

//*********************************************************************************** {

uint16 DirSecCut, DirStart, i, m, ID = 0; DirSecCut = GetDirSecCount(); DirStart = DirStartSec();

for(i = 0; i < DirSecCut; i++) {

ReadBlock(DirStart + i); for(m = 0; m < 16; m++) {

if((BUFFER[m * 32] == 0) || (BUFFER[m * 32] == 0xe5)) return ID; else

ID++; } }

return ID; }

//************************************************************************************ //获得和文件名对应的目录项

uint8 GetFileID(uint8 Name[11], DIR* ID)

//************************************************************************************ {

uint16 DirSecCut, DirStart, i, m; DirSecCut = GetDirSecCount(); DirStart = DirStartSec();

for(i = 0; i < DirSecCut; i++) {

ReadBlock(DirStart + i); for(m = 0; m <16; m++) {

if(IsEqual(Name, &((DIR*)&BUFFER[m * 32])->FileName, 11)) {

*ID = *((DIR*)&BUFFER[m * 32]);

return 1; //找到对应的目录项,返回1. } } }

return 0; //没有找到对应的目录项,返回0.

7

}

//************************************************************************************** //获取一个空的FAT项 uint16 GetNextFAT(void)

//************************************************=************************************* {

uint16 FAT_Count, i;

FAT_Count = BPB_FATSz16 * 256; //FAT表总项数 for(i = 0; i < FAT_Count; i++) {

if(ReadFAT(i) == 0) return i; }

return 0; }

//************************************************************************************** //读取根目录的指定项

void ReadDIR(uint16 Index, DIR* Value)

//************************************************************************************ {

uint32 DirStart = DirStartSec(); ReadBlock(DirStart + Index / 16);

CopyBytes(&BUFFER[(Index % 16) * 32], Value, 32); }

//************************************************************************************* //写根目录的指定项

void WriteDIR(uint16 Index, DIR* Value)

//************************************************************************************* {

uint32 LBA = DirStartSec() + Index / 16; ReadBlock(LBA);

CopyBytes(Value, &BUFFER[(Index % 16) * 32], 32); WriteBlock(LBA); }

//************************************************************************************* //创建一个空文件

void CreateFile(uint8* FileName[11], uint32 Size)

//************************************************************************************* {

uint16 ClusID, ClusNum, ClusNext, i; DIR FileDir;

ClusNum = Size / (BPB_SecPerClus * 512) + 1; EmptyBytes(&FileDir, sizeof(DIR));

8

CopyBytes(FileName, &FileDir.FileName, 11); FileDir.FilePosit.Size = Size;

FileDir.FilePosit.Start = GetNextFAT(); ClusID = FileDir.FilePosit.Start; for(i = 0; i < ClusNum - 1; i++) {

WriteFAT(ClusID, 0xffff); ClusNext = GetNextFAT(); WriteFAT(ClusID, ClusNext); ClusID = ClusNext; }

WriteFAT(ClusID, 0xffff);

WriteDIR(GetEmptyDIR(), &FileDir); }

//************************************************************************************ //复制文件分配表,使其和备份一致 void CopyFAT(void)

//************************************************************************************ {

uint16 FATSz16, RsvdSecCnt, i; FATSz16 = BPB_FATSz16;

RsvdSecCnt = BPB_RsvdSecCnt; for(i = 0; i < FATSz16; i++) {

ReadBlock(RsvdSecCnt + i);

WriteBlock(RsvdSecCnt + FATSz16 + i); } }

//************************************************************************************* //操作文件的数据

void OperateFile(uint8 Write ,uint8 Name[11], uint32 Start, uint32 Length, void* Data) //************************************************************************************* {

uint8 *data = Data;

uint16 BytePerClus, SecPerClus, ClusNum, ClusID, m; uint32 LBA, i; DIR FileDir;

SecPerClus = BPB_SecPerClus;

BytePerClus = BPB_SecPerClus * 512; // 每簇的字节数 GetFileID(Name, &FileDir);

//计算开始位置所在簇的簇号 ClusNum = Start / BytePerClus; ClusID = FileDir.FilePosit.Start;

9

for(i = 0; i < ClusNum; i++) ClusID = ReadFAT(ClusID);

//计算开始位置所在扇区簇内偏移 i = (Start % BytePerClus) / 512;

//计算开始位置扇区内偏移

m = (Start % BytePerClus) % 512;

LBA = ClusConvLBA(ClusID) + m;

if(Write)

ReadBlock(LBA); else

ReadBlock(LBA++);

goto Start;

while(1) {

ClusID = ReadFAT(ClusID); //下一簇簇号 LBA = ClusConvLBA(ClusID);

for(i = 0; i < SecPerClus; i++) {

if(Write)

ReadBlock(LBA); else

ReadBlock(LBA++);

for(m = 0; m < 512; m++) { Start:

if(Write)

BUFFER[m] = *data++; else

*data++ = BUFFER[m];

//如果读取完成就退出 if(--Length == 0) {

if(Write)

WriteBlock(LBA); //回写扇区 return; } }

if(Write)

10

WriteBlock(LBA++); //回写扇区,指针下移 } } }

//--------------------------------------------------------------------------------------

11