用C++实现一个简单的文件系统,能正确描述文件控制块,采用合理的分配方式,实现目录及文件的操作,包括创建、分配、删除、回收等功能,并采用位示图管理空闲盘块。
时间: 2024-05-03 20:18:07 浏览: 132
实现一个简单的文件系统需要考虑以下几个方面:
1. 文件控制块(FCB)的设计
2. 空闲盘块的管理
3. 目录的操作(创建、删除等)
4. 文件的操作(创建、打开、读写等)
下面我将分别介绍这几个方面的实现。
1. 文件控制块(FCB)的设计
FCB是文件系统中最重要的元素之一,它记录了每个文件的属性和位置信息。一个典型的FCB应包括以下信息:
- 文件名:文件的名称。
- 文件类型:文件的类型(例如,文本文件、图像文件等)。
- 文件大小:文件的大小(以字节为单位)。
- 创建时间:文件的创建时间。
- 修改时间:文件的最后修改时间。
- 访问时间:文件的最后访问时间。
- 直接盘块地址:文件的前N个盘块的地址。
- 一级间接盘块地址:文件的第N+1个盘块的地址,用于存储指向其余盘块的指针。
- 二级间接盘块地址:文件的第N+2个盘块的地址,用于存储指向一级间接盘块的指针。
2. 空闲盘块的管理
为了管理空闲盘块,我们可以使用位示图(bit map)来表示每个盘块的状态(是否空闲)。位示图通常是一个数组,其中的每个元素都对应于一个盘块。如果某个盘块是空闲的,则对应的数组元素为0;否则为1。当需要分配一个新的盘块时,我们只需要在位示图中找到第一个为0的元素,并将其置为1即可。
3. 目录的操作
目录是文件系统中组织文件的一种方式。在一个目录中,可以包含其他目录和文件。为了实现目录的操作,我们需要设计一个目录项(directory entry)结构体,它应包含以下信息:
- 文件名:目录项对应的文件名。
- 文件类型:目录项对应的文件类型。
- 直接盘块地址:目录项对应的文件的直接盘块地址。
在文件系统中,根目录是最顶层的目录,通常被命名为“/”。我们可以在根目录下创建其他目录,并在这些目录中创建文件。
4. 文件的操作
在文件系统中,文件的操作包括创建文件、打开文件、读取文件、写入文件和关闭文件等。为了实现这些操作,我们需要设计以下数据结构:
- 文件描述符(file descriptor):每个打开的文件都有一个文件描述符,它记录了文件的位置信息、读写权限等。
- 缓冲区(buffer):由于磁盘读写速度较慢,我们通常会在内存中创建一个缓冲区,来加速文件的读写。
下面是一个简单的文件系统实现的示例代码,供参考:
```c++
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <bitset>
#include <ctime>
using namespace std;
const int BLOCK_SIZE = 1024; // 盘块大小
const int BLOCK_NUM = 1024; // 盘块数量
const int INODE_NUM = 128; // i节点数量
const int NAME_LEN = 20; // 文件名长度
const int DIR_PER_BLOCK = BLOCK_SIZE / sizeof(DirectoryEntry); // 每个目录块中最多可以存储的目录项数量
struct INode {
char name[NAME_LEN]; // 文件名
char type[NAME_LEN]; // 文件类型
int size; // 文件大小
time_t createTime; // 创建时间
time_t modifyTime; // 修改时间
time_t accessTime; // 访问时间
int directBlockAddr[10]; // 直接盘块地址
int indirectBlockAddr[2]; // 一级和二级间接盘块地址
};
struct DirectoryEntry {
char name[NAME_LEN]; // 文件名
char type[NAME_LEN]; // 文件类型
int inodeNum; // i节点号
};
struct FileDescriptor {
int inodeNum; // i节点号
int offset; // 文件位置
bool read; // 是否可读
bool write; // 是否可写
};
struct Buffer {
int blockNum; // 缓冲区对应的盘块号
char data[BLOCK_SIZE]; // 缓冲区数据
bool dirty; // 缓冲区是否已修改
};
vector<INode> inodeTable(INODE_NUM); // i节点表
vector<DirectoryEntry> rootDir(BLOCK_SIZE / sizeof(DirectoryEntry)); // 根目录
vector<Buffer> bufferPool(BLOCK_NUM); // 缓冲区池
bitset<BLOCK_NUM> freeBlock; // 空闲盘块位示图
int findEmptyINode() {
for (int i = 0; i < INODE_NUM; i++) {
if (inodeTable[i].name[0] == 0) {
return i;
}
}
return -1;
}
int findEmptyBlock() {
for (int i = 0; i < BLOCK_NUM; i++) {
if (!freeBlock[i]) {
return i;
}
}
return -1;
}
void writeBlock(int blockNum, char* data) {
fstream fs("disk", ios::in | ios::out | ios::binary);
fs.seekp(blockNum * BLOCK_SIZE);
fs.write(data, BLOCK_SIZE);
fs.close();
}
void readBlock(int blockNum, char* data) {
fstream fs("disk", ios::in | ios::binary);
fs.seekg(blockNum * BLOCK_SIZE);
fs.read(data, BLOCK_SIZE);
fs.close();
}
int getBlockAddr(int inodeNum, int blockNum) {
int addr = inodeTable[inodeNum].directBlockAddr[blockNum];
if (addr == -1) {
int indirectBlockNum = blockNum - 10;
int indirectBlockAddr = inodeTable[inodeNum].indirectBlockAddr[indirectBlockNum / DIR_PER_BLOCK];
if (indirectBlockAddr == -1) {
indirectBlockAddr = findEmptyBlock();
inodeTable[inodeNum].indirectBlockAddr[indirectBlockNum / DIR_PER_BLOCK] = indirectBlockAddr;
freeBlock[indirectBlockAddr] = 1;
}
readBlock(indirectBlockAddr, (char*)bufferPool[indirectBlockAddr].data);
addr = *(int*)(bufferPool[indirectBlockAddr].data + (indirectBlockNum % DIR_PER_BLOCK) * sizeof(int));
if (addr == -1) {
addr = findEmptyBlock();
*(int*)(bufferPool[indirectBlockAddr].data + (indirectBlockNum % DIR_PER_BLOCK) * sizeof(int)) = addr;
bufferPool[indirectBlockAddr].dirty = true;
freeBlock[addr] = 1;
}
inodeTable[inodeNum].directBlockAddr[blockNum] = addr;
}
return addr;
}
void writeINode(int inodeNum) {
int blockNum = inodeNum / (BLOCK_SIZE / sizeof(INode));
int offset = inodeNum % (BLOCK_SIZE / sizeof(INode));
readBlock(blockNum, (char*)bufferPool[blockNum].data);
*(INode*)(bufferPool[blockNum].data + offset * sizeof(INode)) = inodeTable[inodeNum];
bufferPool[blockNum].dirty = true;
}
int readINode(int inodeNum) {
int blockNum = inodeNum / (BLOCK_SIZE / sizeof(INode));
int offset = inodeNum % (BLOCK_SIZE / sizeof(INode));
readBlock(blockNum, (char*)bufferPool[blockNum].data);
inodeTable[inodeNum] = *(INode*)(bufferPool[blockNum].data + offset * sizeof(INode));
return blockNum;
}
int findFileInDir(vector<DirectoryEntry>& dir, string filename) {
for (int i = 0; i < dir.size(); i++) {
if (dir[i].name == filename) {
return dir[i].inodeNum;
}
}
return -1;
}
int findEmptyDirEntry(vector<DirectoryEntry>& dir) {
for (int i = 0; i < dir.size(); i++) {
if (dir[i].name[0] == 0) {
return i;
}
}
return -1;
}
int createFile(string filename, string filetype) {
int inodeNum = findEmptyINode();
if (inodeNum == -1) {
return -1;
}
int dirEntryNum = findEmptyDirEntry(rootDir);
if (dirEntryNum == -1) {
return -1;
}
int blockNum = findEmptyBlock();
if (blockNum == -1) {
return -1;
}
freeBlock[blockNum] = 1;
rootDir[dirEntryNum].inodeNum = inodeNum;
strcpy_s(rootDir[dirEntryNum].name, filename.c_str());
strcpy_s(rootDir[dirEntryNum].type, filetype.c_str());
inodeTable[inodeNum].size = 0;
inodeTable[inodeNum].createTime = time(NULL);
inodeTable[inodeNum].modifyTime = time(NULL);
inodeTable[inodeNum].accessTime = time(NULL);
inodeTable[inodeNum].directBlockAddr[0] = blockNum;
for (int i = 1; i < 10; i++) {
inodeTable[inodeNum].directBlockAddr[i] = -1;
}
for (int i = 0; i < 2; i++) {
inodeTable[inodeNum].indirectBlockAddr[i] = -1;
}
writeBlock(blockNum, (char*)bufferPool[blockNum].data);
writeINode(inodeNum);
return inodeNum;
}
int openFile(string filename, bool read, bool write) {
int inodeNum = findFileInDir(rootDir, filename);
if (inodeNum == -1) {
return -1;
}
FileDescriptor fd;
fd.inodeNum = inodeNum;
fd.offset = 0;
fd.read = read;
fd.write = write;
return 0;
}
int writeToFile(int fd, char* data, int len) {
FileDescriptor& fileDesc = *(FileDescriptor*)&bufferPool[fd].data;
INode& inode = inodeTable[fileDesc.inodeNum];
int blockNum = fileDesc.offset / BLOCK_SIZE;
int offsetInBlock = fileDesc.offset % BLOCK_SIZE;
int bytesWritten = 0;
while (bytesWritten < len) {
if (inode.size < (blockNum + 1) * BLOCK_SIZE) {
int blockAddr = getBlockAddr(fileDesc.inodeNum, blockNum);
readBlock(blockAddr, bufferPool[blockAddr].data);
int bytesToWrite = min(len - bytesWritten, BLOCK_SIZE - offsetInBlock);
memcpy(bufferPool[blockAddr].data + offsetInBlock, data + bytesWritten, bytesToWrite);
bufferPool[blockAddr].dirty = true;
bytesWritten += bytesToWrite;
fileDesc.offset += bytesToWrite;
inode.size += bytesToWrite;
inode.modifyTime = time(NULL);
}
else {
int indirectBlockNum = blockNum - 10;
int indirectBlockAddr = inode.indirectBlockAddr[indirectBlockNum / DIR_PER_BLOCK];
if (indirectBlockAddr == -1) {
indirectBlockAddr = findEmptyBlock();
inode.indirectBlockAddr[indirectBlockNum / DIR_PER_BLOCK] = indirectBlockAddr;
freeBlock[indirectBlockAddr] = 1;
writeINode(fileDesc.inodeNum);
}
readBlock(indirectBlockAddr, bufferPool[indirectBlockAddr].data);
int* blockAddrPtr = (int*)(bufferPool[indirectBlockAddr].data + (indirectBlockNum % DIR_PER_BLOCK) * sizeof(int));
if (*blockAddrPtr == -1) {
*blockAddrPtr = findEmptyBlock();
freeBlock[*blockAddrPtr] = 1;
writeBlock(indirectBlockAddr, bufferPool[indirectBlockAddr].data);
}
blockNum++;
offsetInBlock = 0;
}
}
return bytesWritten;
}
int readFromFile(int fd, char* buff, int len) {
FileDescriptor& fileDesc = *(FileDescriptor*)&bufferPool[fd].data;
INode& inode = inodeTable[fileDesc.inodeNum];
int blockNum = fileDesc.offset / BLOCK_SIZE;
int offsetInBlock = fileDesc.offset % BLOCK_SIZE;
int bytesRead = 0;
while (bytesRead < len) {
if (inode.size <= blockNum * BLOCK_SIZE) {
break;
}
int blockAddr = getBlockAddr(fileDesc.inodeNum, blockNum);
readBlock(blockAddr, bufferPool[blockAddr].data);
int bytesToRead = min(len - bytesRead, BLOCK_SIZE - offsetInBlock);
memcpy(buff + bytesRead, bufferPool[blockAddr].data + offsetInBlock, bytesToRead);
bytesRead += bytesToRead;
fileDesc.offset += bytesToRead;
offsetInBlock += bytesToRead;
if (offsetInBlock >= BLOCK_SIZE) {
blockNum++;
offsetInBlock = 0;
}
}
inode.accessTime = time(NULL);
return bytesRead;
}
void closeFile(int fd) {
bufferPool[fd].dirty = false;
}
void deleteFile(string filename) {
int inodeNum = findFileInDir(rootDir, filename);
if (inodeNum == -1) {
return;
}
INode& inode = inodeTable[inodeNum];
for (int i = 0; i < 10; i++) {
if (inode.directBlockAddr[i] != -1) {
freeBlock[inode.directBlockAddr[i]] = 0;
inode.directBlockAddr[i] = -1;
}
}
for (int i = 0; i < 2; i++) {
if (inode.indirectBlockAddr[i] != -1) {
readBlock(inode.indirectBlockAddr[i], (char*)bufferPool[inode.indirectBlockAddr[i]].data);
for (int j = 0; j < BLOCK_SIZE / sizeof(int); j++) {
int blockAddr = *(int*)(bufferPool[inode.indirectBlockAddr[i]].data + j * sizeof(int));
if (blockAddr != -1) {
freeBlock[blockAddr] = 0;
}
}
freeBlock[inode.indirectBlockAddr[i]] = 0;
inode.indirectBlockAddr[i] = -1;
}
}
inode.name[0] = 0;
inode.type[0] = 0;
inode.size = 0;
inode.createTime = 0;
inode.modifyTime = 0;
inode.accessTime = 0;
writeINode(inodeNum);
for (int i = 0; i < rootDir.size(); i++) {
if (rootDir[i].inodeNum == inodeNum) {
rootDir[i].inodeNum = -1;
rootDir[i].name[0] = 0;
rootDir[i].type[0] = 0;
break;
}
}
}
int main() {
// 初始化空闲盘块位示图
freeBlock.reset();
freeBlock[0] = 1; // 第0块是引导块,已使用
freeBlock[1] = 1; // 第1块是超级块,已使用
for (int i = 2; i < 10; i++) {
freeBlock[i] = 1; // 前10块是i节点表和位示图,已使用
}
freeBlock[10] = 1; // 第10块是根目录块,已使用
// 初始化根目录
rootDir[0].inodeNum = 0;
strcpy_s(rootDir[0].name, "/");
strcpy_s(rootDir[0].type, "dir");
// 初始化i节点表
for (int i = 0; i < INODE_NUM; i++) {
inodeTable[i].name[0] = 0;
inodeTable[i].type[0] = 0;
inodeTable[i].size = 0;
inodeTable[i].createTime = 0;
inodeTable[i].modifyTime = 0;
inodeTable[i].accessTime = 0;
for (int j = 0; j < 10; j++) {
inodeTable[i].directBlockAddr[j] = -1;
}
for (int j = 0; j < 2; j++) {
inodeTable[i].indirectBlockAddr[j] = -1;
}
}
// 初始化缓冲区池
for (int i = 0; i < BLOCK_NUM; i++) {
bufferPool[i].blockNum = i;
bufferPool[i].dirty = false;
}
// 初始化文件系统
fstream fs("disk", ios::out | ios::binary);
fs
阅读全文