杭州电子科技大学简单文件系统的实现的实验报告.doc

杭州电子科技大学
操作系统课程设计

课程设计题目：简单文件系统的实现

姓名：徐凯辉

班级：12052315

学号：12224679

学院：计算机学院

专业：计算机科学与技术

负责老师：贾刚勇

报告完成日期：2014.12.30

简单文件系统的实现

一， 课程设计的目的
1. 通过具体的文件爱你存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部数据结、功能及实现过程的理解
二， 设计要求
1. 在内存中开辟一个虚拟磁盘空间作为文件存储分区，在其上实现一个简单的基于多级目录的但用户单任务系统的文件系统。在退出文件系统的使用时，应将虚拟文件系统一个Windows文件的方式保存到磁盘中，以便下次再将它恢复到内存的虚拟磁盘空间中
2. 文件存储空间的分配可采用显示链接分配或其它方法
3. 空闲磁盘空间的管理可选择位示图或其它方法
4. 文件目录结构采用多级目录结构
5. 需要提供一以下操作命令
i. Format
ii. Mkdir
iii. Rmdir
iv. Ls
v. Cd
vi. Create
vii. Open
viii. Close
ix. Write
x. Read
xi. Rm
xii. Exit
三， 程序设计思想以及总流程图
1. 程序设计思想
i. 首先，在文件系统启动时，申请一块较大的内存，用来当作文件系统的磁盘空间
ii. 然后，对其进行格式化，虚拟磁盘的空间布局是仿照FAT16文件系统，结构如下：
1块 2块 2块 995块
引导块 FAT1 FAT2 数据区
格式化时，主要包括引导块，FAT1，FAT2，的一些初始化工作
例如设置文件魔数，文件系统的信息，FAT1，FAT2的信息等等
iii. 根据用户输入的命令，调用对应的函数.
2. 程序流程图
程序启动

加载文件系统

文件系统存在

创建新的文件系统并格式化
文件系统不存在

等待用户输入命令

Create
Mkdir
ls

Exit
。。。

四， 系统关键数据结构

（1）文件控制块FCB
用于记录文件的描述和控制信息，每个文件设置一个FCB，它也是文件的目录项的内容。
typedef struct FCB //仿照FAT16设置的
{
char filename[8]; //文件名
char exname[3];//文件扩展名
unsigned char attribute;//文件属性字段：为简单起见，我们只为文件设置了两种属性：
//值为0时表示目录文件，值为1时表示数据文件
unsigned short time;//文件创建时间
unsigned short data;//文件创建日期
unsigned short first;//文件起始盘块号
unsigned long length;//文件长度（字节数）
char free；//表示目录项是否为空，若值为0，表示空，值为1，表示已分配
}fcb;

（2）文件分配表FAT

typedef struct FAT
{
unsigned short id;
}fat;

（3）用户打开文件表USEROPEN
当打开一个文件时，必须将文件的目录项中的所有内容全部复制到内存中，同时还要记录有关文件操作的动态信息，如读写指针的值等。在本实例中实现的是一个用于单用户单任务系统的文件系统，为简单起见，我们把用户文件描述符表和内存FCB表合在一起，称为用户打开文件表，表项数目为10，即一个用户最多可同时打开10个文件。然后用一个数组来描述，则数组下标即某个打开文件的描述符。另外，我们在用户打开文件表中还设置了一个字段“char dir[80]”，用来记录每个打开文件所在的目录名，以方便用户打开不同目录下具有相同文件名的不同文件。
typedef struct USEROPEN
{
char filename[8]; //文件名
char exname[3];//文件扩展名
unsigned char attribute;//文件属性：值为0时表示目录文件，值为1时表示数据文件
unsigned short time;//文件创建时间
unsigned short data;//文件创建日期
unsigned short first;//文件起始盘块号
unsigned long length;//文件长度（对数据文件是字节数，对目录文件可以是目录项个数）
char free；//表示目录项是否为空，若值为0，表示空，值为1，表示已分配
//前面内容是文件的FCB中的内容。
// 下面设置的dirno和diroff记录了相应打开文件的目录项在父目录文件中的位置，//这样如果该文件的fcb被修改了，则要写回父目录文件时比较方便
int dirno; //相应打开文件的目录项在父目录文件中的盘块号
int diroff；// 相应打开文件的目录项在父目录文件的dirno盘块中的目录项序号
char dir[MAXOPENFILE][80]; //相应打开文件所在的目录名，这样方便快速检查出
//指定文件是否已经打开
int count; //读写指针在文件中的位置
char fcbstate; //是否修改了文件的FCB的内容，如果修改了置为1，否则为0
char topenfile; //表示该用户打开表项是否为空，若值为0，表示为空，否则表示已
//被某打开文件占据
}useropen;

（4）引导块BLOCK0
在引导块中主要存放逻辑磁盘的相关描述信息，比如磁盘块大小、磁盘块数量、文件分配表、根目录区、数据区在磁盘上的起始位置等。如果是引导盘，还要存放操作系统的引导信息。本实例是在内存的虚拟磁盘中创建一个文件系统，因此所包含的内容比较少，只有磁盘块大小、磁盘块数量、数据区开始位置、根目录文件开始位置等。
typedef struct BLOCK0 //引导块内容
{
//存储一些描述信息，如磁盘块大小、磁盘块数量、最多打开文件数等、
char information[200];
unsigned short root; //根目录文件的起始盘块号
unsigned char *startblock; //虚拟磁盘上数据区开始位置
}block0;

4．全局变量定义
（1）unsigned char *myvhard： 指向虚拟磁盘的起始地址
（2）useropen openfilelist[MAXOPENFILE]： 用户打开文件表数组
（3）useropen *ptrcurdir： 指向用户打开文件表中的当前目录所在打开文件表项的位置；
（4）char currentdir[80]： 记录当前目录的目录名（包括目录的路径）
（5）unsigned char* startp： 记录虚拟磁盘上数据区开始位置
5．虚拟磁盘空间布局
由于真正的磁盘操作需要涉及到设备的驱动程序，所以本实例是在内存中申请一块空间作为虚拟磁盘使用，我们的文件系统就建立在这个虚拟磁盘上。虚拟磁盘一共划分成1000个磁盘块，每个块1024个字节，其布局格式是模仿FAT文件系统设计的，其中引导块占一个盘块，两张FAT各占2个盘块，剩下的空间全部是数据区，在对虚拟磁盘进行格式化的时候，将把数据区第1块（即虚拟磁盘的第6块）分配给根目录文件，如图3-3所示：

图3-3 虚拟磁盘空间布局
五， 系统详细设计、
1， 格式化磁盘
// 磁盘格式化函数
void my_format()
{
block0 *b0;
unsigned char *p;
fat *fat1, *fat2;
int i;
fcb *root, *root0;
time_t rawtime;
struct tm *timeinfo;
FILE *fp;

printf("Start format filesystem ...\n");
// 将虚拟磁盘第一个块作为引导块
b0 = (block0 *)myvhard;
// 文件系统的魔数
memcpy(b0->magic_number, "10101010", 8);
// 文件系统的描述信息
strcpy(b0->infomation, "My FileSystem V1.0\n");
b0->root = 5;
b0->startblock = myvhard + 5 * BLOCKSIZE;

// 建立两张完全一样的FAT表
p = myvhard;
fat1 = (fat *)(p + BLOCKSIZE); // 第 1 个块
fat2 = (fat *)(p + 3 * BLOCKSIZE); // 第 3 个块
for (i = 0; i < 5; i++)
{
// 前 5 个块是设置为已分配
fat1[i].id = END;
fat2[i].id = END;
}
for (; i < SIZE/BLOCKSIZE; i++)
{
// 后 995 个设置为空闲
fat1[i].id = FREE;
fat2[i].id = FREE;
}

fat1[5].id = END; // 根目录文件使用
fat2[5].id = END;

// 创建根目录文件root，将数据区第1块（即虚拟磁盘的第6块）分配给根目录文件
// 在该磁盘块中创建两个特殊的目录项：“.”和“..”，其内容除了文件名不同之外，其他字段完全相同
p += 5 * BLOCKSIZE;
root = (fcb *)p;
memset(root, 0, BLOCKSIZE);
// 创建目录项 '.'
strcpy(root->filename, "."); // 根目录文件名
strcpy(root->exname, "di"); // 根目录文件拓展名
root->attribute = 0;

rawtime = time(NULL); // 获取时间，以秒计，从1970年1月1日起算，存于rawtime
timeinfo = localtime(&rawtime); // 转为当地时间
root->time = timeinfo->tm_hour * 2048 + timeinfo->tm_min * 32 + timeinfo->tm_sec / 2; // 文件创建时间
root->date = (timeinfo->tm_year - 80) * 512 + (timeinfo->tm_mon + 1) * 32 + timeinfo->tm_mday; // 文件创建创建日期
root->first = 5; // 文件起始盘块号
root->length = 2 * sizeof(fcb);
root->free = 1;
// 复制目录项 '.' 为 '..'
root0 = root + 1;
memcpy(root0, root, sizeof(fcb));
strcpy(root0->filename, "..");

root0++;
for (i = 2; i < (int)(BLOCKSIZE/sizeof(fcb)); i++)
{
strcpy(root0->filename, "");
root0++;
}
// 写入文件
fp = fopen(filename , "w");
fwrite(myvhard, SIZE, 1, fp);
fclose(fp);

update_openfilelist0();
printf("Format filesystem ok.\n");
}
2， 创建目录
a) 调用do_read读入当前目录文件到内存，检查新建文件目录是否重名
b) 分配一个空闲的打开文件表项
c) 分配一个空闲的盘块
d) 在当前目录中问新建目录寻找一个空闲的目录项
e) 设置FCB，文件的属性信息
f) 创建特殊的两个目录项‘.’,‘..’
g) 返回

// 创建子目录
void my_mkdir(char *dirname)
{
int filelen;
fcb *fcbptr, fcbtmp, fcbtmp0;
char text[MAX_TEXT_SZIE], *p;
int i, fd;
unsigned short numOfBlock;
unsigned char *blockptr;
time_t rawtime;
struct tm *timeinfo;
fat *fat1;

fat1 = (fat *)(myvhard + BLOCKSIZE);
// 调用do_read()读入当前目录文件内容到内存
openfilelist[currfd].count = 0;
filelen = do_read(currfd, (int)openfilelist[currfd].length, text);
fcbptr = (fcb *)text;

// 检查当前目录下新建目录文件是否重名
for (i = 0; i < (int)(filelen/sizeof(fcb)); i++)
{
if (strcmp(dirname, fcbptr->filename) == 0)
{
printf("Error : the dirname is already exist.\n");
return ;
}
fcbptr++;
}

// 为新建子目录文件分配一个空闲打开文件表项
fd = getFreeOpenfilelist();
printf("Find free openfilelist : %d\n", fd);
if (fd < 0)
{
return;
}
// 为新目录文件分配一个盘块
numOfBlock = getFreeBLOCK();
printf("Find free block : %d\n", numOfBlock);
if (numOfBlock < 0)
{
my_close(fd);
return;
}
fat1[numOfBlock].id = END;
fcbptr = (fcb *)text;
// 在当前目录中为新建目录文件寻找一个空闲的目录项或为其追加一个新的目录项
for (i = 0; i < (int)(filelen/sizeof(fcb)); i++)
{
if (strcmp(fcbptr->filename, "") == 0)
break;
fcbptr++;
}
openfilelist[currfd].count = i * sizeof(fcb);
openfilelist[currfd].fcbstate = 1;
// 在当前目录新建目录项
strcpy(fcbtmp.filename, dirname);
strcpy(fcbtmp.exname, "di");
fcbtmp.attribute = 0;
rawtime = time(NULL); // 获取时间，以秒计，从1970年1月1日起算，存于rawtime
timeinfo = localtime(&rawtime); // 转为当地时间
fcbtmp.time = timeinfo->tm_hour * 2048 + timeinfo->tm_min * 32 + timeinfo->tm_sec / 2; // 文件创建时间
fcbtmp.date = (timeinfo->tm_year - 80) * 512 + (timeinfo->tm_mon + 1) * 32 + timeinfo->tm_mday; // 文件创建创建日期
fcbtmp.first = numOfBlock;
fcbtmp.length = 2 * sizeof(fcb);
fcbtmp.free = 1;
do_write(currfd, (char *)(&fcbtmp), sizeof(fcb), 2);
openfilelist[currfd].length += sizeof(fcb);

// 设置新建目录项的打开文件表项
strcpy(openfilelist[fd].filename, fcbtmp.filename);
strcpy(openfilelist[fd].exname, fcbtmp.exname);
openfilelist[fd].attribute = fcbtmp.attribute;
openfilelist[fd].time = fcbtmp.time;
openfilelist[fd].date = fcbtmp.date;
openfilelist[fd].first = fcbtmp.first;
openfilelist[fd].length = fcbtmp.length;
openfilelist[fd].free = fcbtmp.free;
openfilelist[fd].dirno = openfilelist[currfd].first;
openfilelist[fd].diroff = i;
strcpy(openfilelist[fd].dir[fd], openfilelist[currfd].dir[currfd]);
p = openfilelist[fd].dir[fd];
while (*p != '\0') p++;
strcpy(p, dirname);
while (*p != '\0') p++;
*p = '/'; p++; *p = '\0';
openfilelist[fd].count 0;
openfilelist[fd].fcbstate = 0;
openfilelist[fd].topenfile = 1;

// 在新建目录文件所分配到的磁盘块中建立“.“和“..”
blockptr = (unsigned char *)(myvhard + numOfBlock * BLOCKSIZE);
fcbptr = (fcb *)blockptr;
// 创建目录项 '.'
strcpy(fcbtmp.filename, "."); // 根目录文件名
strcpy(fcbtmpexname, "di"); // 根目录文件拓展名
fcbtmp.attribute = 0;
rawtime = time(NULL); // 获取时间，以秒计，从1970年1月1日起算，存于rawtime
timeinfo = localtime(&rawtime); // 转为当地时间
fcbtmp.time = timeinfo->tm_hour * 2048 + timeinfo->tm_min * 32 + timeinfo->tm_sec / 2; // 文件创建时间
fcbtmp.date = (timeinfo->tm_year - 80) * 512 + (timeinfo->tm_mon + 1) * 32 + timeinfo->tm_mday; // 文件创建创建日期
fcbtmp.first = numOfBlock; // 文件起始盘块号
fcbtmp.length = 2 * sizeof(fcb);
fcbtmp.free = 1;

// 复制目录项 "." 为 ".."
memcpy(&fcbtmp0, &fcbtmp, sizeof(fcb));
strcpy(fcbtmp0.filename, "..");
fcbtmp0.first = openfilelist[currfd].first;
fcbtmp0.length = openfilelist[currfd].length;

do_write(fd, (char *)(&fcbtmp), sizeof(fcb), 2);
do_write(fd, (char *)(&fcbtmp0), sizeof(fcb), 2);

// 更新当前目录文件的长度
openfilelist[currfd].count = 0;
do_read(currfd, (int)openfilelist[currfd].length, text);
fcbptr = (fcb *)text;
fcbptr->length = openfilelist[currfd].length;
openfilelist[currfd].count = 0;
do_write(currfd, text, (int)fcbptr->length, 2);
my_close(fd);
}
3， Cd命令
a) Open指定的目录名，调用read读入该父目录到内存
b) 检查新的当前目录名是否存在
c) 关闭原当前目录
d) 设置当前目录为该目录
4， Rmdir命令
a) Read读入当前目录文件内容到内存，检查要删除的文件目录是否存在
b) 检查该目录是否为空
c) 检查是否已经打开，打开用close则关闭
d) 回收给目录文件的磁盘块
e) 修改该目录文件的目录项
f) 修改用户打开表项的长度信息
g) 返回
5， Ls命令
a) Read当前目录到内存
b) 读出目录文件的信息，显示到屏幕上
c) 返回
6， Create命令
a) 分配一个空闲的打开文件表项
b) 检查新文件的父目录是否打开
c) Read该父目录的文件到内存，并检测新建的文件名是否重名
d) 检查是否有空闲盘块
e) 寻找空闲的目录项
f) 准备好新文件的FCB
g) 调用close关闭打开的父目录文件
h) 返回
7， Rm命令
a) 检查要删除的文件的父目录是否已打开
b) Read父目录到内存
c) 检查文件是否打开
d) 回收磁盘快
e) 清空该文件的目录项
f) 修改用户打开文件表项中的长度信息
g) 返回
8， Open命令
a) 检查该文件名是否存在
b) Read该父目录到内存
c) 检查用户打开的文件表中是否有空闲表项
d) 为该文件填写空白用户打开文件表项内容
e) 返回
// 打开文件
int my_open(char *filename)
{
char *fname, *exname, *p;
int i, fd;
char text[MAX_TEXT_SZIE];
fcb *fcbptr;
int fcblen;
char *direxname = "di";

fname = strtok(filename, ".");
exname = strtok(NULL, ".");
if (exname == NULL)
{
exname = direxname;
}
// 检查该文件是否以及打开
for (i = 0; i < MAXOPENFILE; i++)
{
if (strcmp(fname, openfilelist[i].filename) == 0 &&
strcmp(exname, openfilelist[i].exname) == 0)
{
printf("Error : The file is already open. The FileHandle is %d.\n", i)
return -1;
}
}

// 读出父目录文件到内存
openfilelist[currfd].count = 0;
fcblen = do_read(currfd, (int)openfilelist[currfd].length, text);
fcbptr = (fcb *)text;
// 检查该目录下欲打开文件是否存在
for (i = 0; i < (int)(fcblen/sizeof(fcb)); i++)
{
if (strcmp(fname, fcbptr->filename) == 0 && strcmp(exname, fcbptr->exname) == 0)
{
break;
}
fcbptr++;
}
if (i >= (int)(fcblen/sizeof(fcb)))
{
printf("Error : The file not exist.\n");
return -1;
}
// 为打开文件分配一个空表项
fd = getFreeOpenfilelist();
if (fd == -1)
{
return -1;
}
// 为该文件填写空白用户打开文件表表项，读写指针置为0
strcpy(openfilelist[fd].filename, fcbptr->filename);
strcpy(openfilelist[fd].exname, fcbptr->exname);
openfilelist[fd].attribute = fcbptr->attribute;
openfilelist[fd].time fcbptr->time;
openfilelist[fd].date = fcbptr->date;
openfilelist[fd].first = fcbptr->first;
openfilelist[fd].length = fcbptr->length;
openfilelist[fd].free = fcbptr->free;
openfilelist[fd].dirno = openfilelist[currfd].first;
openfilelist[fd].diroff = i;
strcpy(openfilelist[fd].dir[fd], openfilelist[currfd].dir[currfd]);
p = openfilelist[fd].dir[fd];
while (*p != '\0') p++;
strcpy(p, fname);
while (*p != '\0') p++;
if (fcbptr->attribute == 0)
{
*p = '/'; p++; *p = '\0';
}
else
{
*p = '.'; p++;
strcpy(p, fcbptr->exname);
}
openfilelist[fd].count = 0;
openfilelist[fd].fcbstate = 0;
openfilelist[fd].topenfile = 1;

printf("The FileHandle is %d.\n", fd);
return fd;
}
9， Close
a) 检查fd的有效性
b) 检查用户打开文件表表项的fcbstate字段
c) 回收该文件占据的用户打开文件表表项
d) 返回
10， Write命令
a) 检查fd的有效性
b) 提示用户输入写方式
c) 提示用户输入内容
d) 调用do_write（）将键入的内容写入到文件中
e) 返回写入的字节数
// 写文件
int my_write(int fd)
{
fat *fat1, *fatptr;
unsigned char *p;
int wstyle, numOfBlock, writelen, temp;
char text[MAX_TEXT_SZIE];

fat1 = (fat *)(myvhard + BLOCKSIZE);
// 检查fd的有效性
if(fd > MAXOPENFILE)
{
printf("Error : The file is not exist.\n");
return -1;
}
// 提示并等待用户输入写方式：(1. 截断写, 2. 覆盖写, 3. 追加写)
wstyle = 0;
while(wstyle < 1 || wstyle > 3)
{
printf("Please select write style:\n");
printf("1. cut write\t2. cover write\t3. add write\n");
scanf("%d", &wstyle);
getchar();
switch(wstyle)
{
case 1: // 截断写
numOfBlock = openfilelist[fd].first;
// 释放文件除第一快外的其他磁盘空间内容
while (numOfBlock != END)
{
fatptr = fat1 + numOfBlock;
numOfBlock = fatptr->id;
fatptr->id = FREE;
}
numOfBlock = openfilelist[fd].first;
fatptr = fat1 + numOfBlock;
fatptr->id = END
// 将内存用户打开文件表项中文件长度修改为0，将读写指针置为0
openfilelist[fd].length = 0;
openfilelist[fd].count = 0;
break;
case 2: // 覆盖写
break;
case 3: // 追加写
// 将读写指针移到文件末尾
openfilelist[fd].count = 0;
numOfBlock = openfilelist[fd].first;
fatptr = fat1 + numOfBlock;
temp = fatptr->id;
while (temp != END)
{
numOfBlock = temp;
fatptr = fat1 +