操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

文件管理系统模拟

1.实验目的

通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现 2.实验内容

为Linux系统设计一个简单的二级文件系统。要求做到以下几点:

(1)可以实现下列几条命令(至少4条)

login 用户登录

dir 列文件目录

create 创建文件

delete 删除文件

open 打开文件

close 关闭文件

read 读文件

write 写文件

(2)列目录时要列出文件名、物理地址、保护码和文件长度;

(3)源文件可以进行读写保护。

3.实验提示

(1)首先应确定文件系统的数据结构:主目录、子目录及活动文件等。主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。

(2)用户创建的文件，可以编号存储于磁盘上。入file0,file1,file2…并以编号作为物理地址，在目录中进行登记。

4.源代码

#include DISK_NUM*sizeof(struct fatitem)

#include //FAT表大小

#include #define ROOT_DISK_NO

FATSIZE/DISKSIZE+1 #define MEM_D_SIZE 1024*1024 //根目录起始盘块号//总磁盘空间为1M #define ROOT_DISK_SIZE #define DISKSIZE 1024

sizeof(struct direct) //根

//磁盘块的大小1K 目录大小

#define DISK_NUM 1024 #define DIR_MAXSIZE 1024

//磁盘块数目1K //路径最大长度为1KB #define FATSIZE #define MSD 5 //最大子目录数5 }openitem[MOFN]; #define MOFN 5 int cur_size; /*当前打文件的

//最大文件深度为5 数目*/

#define MAX_WRITE 1024*128 };

//最大写入文字长度128KB

struct fatitem *fat; /*FAT表*/ struct fatitem /* size 8*/ struct direct *root; /*根目录*/ { struct direct *cur_dir; /*当前int item; /*存放文件下一个磁目录*/

盘的指针*/ struct opentable u_opentable; /*

char em_disk; /*磁盘块是否空闲文件打开表*/

标志位 0 空闲*/ int fd=-1; /*文件打开表的序}; 号*/

char *bufferdir; /*记录当前路struct direct 径的名称*/

{ char *fdisk; /*虚拟磁盘起始地

/*-----文件控制快信息-----*/ 址*/

struct FCB

{ void initfile();

char name[9]; /*文件/目录void format();

8位*/ void enter(); 名

char property; /*属性 1位void halt(); 目录 0位普通文件*/ int create(char *name);

int size; /*文件/目录字int open(char *name); 节数、盘块数)*/ int close(char *name);

int firstdisk; /*文件/目int write(int fd,char *buf,int 录起始盘块号*/ len);

int next; /*子目录起始盘int read(int fd,char *buf); 块号*/ int

del(char *name);

int sign; /*1是根目录 0int mkdir(char *name); 不是根目录*/ int rmdir(char *name);

void dir();

}directitem[MSD+2]; int cd(char *name);

void print();

}; void show();

struct opentable void initfile() { {

struct openttableitem fdisk = (char

{ *)malloc(MEM_D_SIZE*sizeof(char)

char name[9]; /*文件名*/ ); /*申请 1M空间*/

int firstdisk; /*起始盘块 format();

号*/

int size; /*文件的大小*/ }

me,".");

void format() root->directitem[0].next = { root-

>directitem[0].firstdisk;

int i; root->directitem[0].property

FILE *fp; = '1';

root->directitem[0].size =

fat = (struct fatitem ROOT_DISK_SIZE;

*)(fdisk+DISKSIZE); /*计算FAT表-------指向上一级目录的目录 /*

地址，引导区向后偏移 1k)*/ 项---------*/

/*-----初始化FAT表 root->directitem[1].sign = 1; ------------*/ root->directitem[1].firstdisk

fat[0].item=-1; /*引导块*/ = ROOT_DISK_NO;

fat[0].em_disk='1'; strcpy(root->directitem[1].na

me,"..");

for(i=1;idirectitem[1].next = /*存放 FAT 表的磁盘块号*/ root->directitem[0].firstdisk;

{ root->directitem[1].property

fat[i].item=i+1; = '1';

fat[i].em_disk='1'; root->directitem[1].size =

} ROOT_DISK_SIZE;

if((fp =

fat[ROOT_DISK_NO].item=-1; fopen("disk.dat","wb"))==NULL) /*存放根目录的磁盘块号*/ {

fat[ROOT_DISK_NO].em_disk='1' printf("Error:\n Cannot ; open file \n");

return;

for(i=ROOT_DISK_NO+1;i

UM;i++) for(i=2;i

{ 录初始化为空-*/

fat[i].item = -1; {

fat[i].em_disk = '0'; root->directitem[i].sign =

} 0;

/*---------------------------

--------------------*/ root->directitem[i].firstdisk

root = (struct direct = -1;

*)(fdisk+DISKSIZE+FATSIZE); /*根

目录的地址*/ strcpy(root->directitem[i].na

/*初始化目录*/ me,"");

/*---------指向当前目录的目录 root->directitem[i].next = 项---------*/ -1;

root->directitem[0].sign = 1;

root->directitem[0].firstdisk root->directitem[i].property =

ROOT_DISK_NO; = '0';

strcpy(root->directitem[0].na root->directitem[i].size =

0; }

} fat = (struct fatitem

*)(fdisk+DISKSIZE); /*找到FAT表

地址*/

root = (struct direct if((fp =

fopen("disk.dat","wb"))==NULL) *)(fdisk+DISKSIZE+FATSIZE);/*找

{ 到根目录地址*/

printf("Error:\n Cannot fclose(fp);

open file \n"); /*--------------初始化用户打

return; 开表------------------*/

} for(i=0;i

if(fwrite(fdisk,MEM_D_SIZE,1, {

fp)!=1) /*把虚拟磁盘空间保存到磁

盘文件中*/ strcpy(u_opentable.openitem[i

{ ].name,"");

printf("Error:\n File

u_opentable.openitem[i].firstwrite error! \n");

disk = -1; }

fclose(fp); u_opentable.openitem[i].size

= 0; } }

void enter() u_opentable.cur_size = 0; {

FILE *fp; cur_dir = root; /*当前目录为根

int i; 目录*/

bufferdir = (char

fdisk = (char

*)malloc(DIR_MAXSIZE*sizeof(char*)malloc(MEM_D_SIZE*sizeof(char)));

); /*申请 1M空间*/ strcpy(bufferdir,"Root:");

if((fp=fopen("disk.dat","rb")}

)==NULL)

{ void halt()

printf("Error:\nCannot {

open file\n"); FILE *fp;

return; int i;

}

if(!fread(fdisk,MEM_D_SIZE,1, if((fp=fopen("disk.dat","wb")fp)) /*把磁盘文件disk.dat 读入)==NULL)

虚拟磁盘空间(内存)*/ {

{ printf("Error:\nCannot

printf("Error:\nCannot open file\n");

read file\n"); return;

exit(0); }

if(!fwrite(fdisk,MEM_D_SIZE,1 return(-2);

,fp)) /*把虚拟磁盘空间(内存)内容

读入磁盘文件disk.dat */ if(u_opentable.cur_size>=MOFN) /*

{ 打开文件太多*/

printf("Error:\nFile write return(-3);

error!\n");

}

fclose(fp);

for(j=ROOT_DISK_NO+1;j

free(fdisk); j++) /*找到空闲盘块 j 后退出*/

free(bufferdir); {

return; if(fat[j].em_disk=='0') } break;

}

int create(char *name) if(j>=DISK_NUM)

{ return(-5);

fat[j].em_disk = '1'; /*将空

int i,j; 闲块置为已经分配*/

/*-----------填写目录项

if(strlen(name)>8) /*文件名大-----------------*/

于 8位*/

return(-1); strcpy(cur_dir->directitem[i].na

me,name);

for(j=2;j

建文件是否与已存在的文件重名*/ cur_dir->directitem[i].firstdisk

{ = j;

cur_dir->directitem[i].size =

if(!strcmp(cur_dir->directite0;

m[j].name,name)) cur_dir->directitem[i].next =

break; j;

}

if(jdirectitem[i].property = 在*/ '0'; return(-4);

/*------------------------------

for(i=2;i

一个空闲子目录*/ fd = open(name);

{ return 0;

if(cur_dir->directitem[i].fir}

stdisk==-1)

break; int open(char *name)

} {

if(i>=MSD+2) /*无空目录项*/ int i, j;

/*--------------填写表项的相

for(i=2;i

{ u_opentable.openitem[j].firstdis

k =

if(!strcmp(cur_dir->directitecur_dir-

>directitem[i].firstdiskm[i].name,name)) ;

break;

} strcpy(u_opentable.openitem[j].n

if(i>=MSD+2) ame,name);

return(-1); u_opentable.openitem[j].size

/*--------是文件还是目录= cur_dir->directitem[i].size; -----------------------*/ u_opentable.cur_size++;

if(cur_dir->directitem[i].pro /*----------返回用户打开表表

perty=='1') 项的序号

return(-4); --------------------------*/

return(j);

件是否打开 /*--------文}

-----------------------*/

for(j=0;j

{ {

int i;

if(!strcmp(u_opentable.openit

em[j].name,name)) for(i=0;i

break; {

}

if(j

return(-2); em[i].name,name))

break;

}

if(i>=MOFN)

if(u_opentable.cur_size>=MOFN) /* return(-1);

文件打开太多*/ /*-----------清空该文件的用

return(-3); 户打开表项的内容

---------------------*/

/*--------查找一个空闲用户打

开表项-----------------------*/ strcpy(u_opentable.openitem[i].n for(j=0;j

{

u_opentable.openitem[i].firstdis

if(u_opentable.openitem[j].fik = -1;

rstdisk==-1) u_opentable.openitem[i].size

break; = 0;

} u_opentable.cur_size--;

下标-*/

/*------找到的item 是该文件的

return 0; 最后一块磁盘块

} -------------------*/

while(fat[item].item!=-1) int write(int fd, char *buf, int { len) item =fat[item].item; /*-

*/ { 查找该文件的下一盘块--

} char *first;

int item, i, j, k;

int ilen1, ilen2, modlen, temp; /*-----计算出该文件的最末地址/*----------用 $ 字符作为空格 -------*/

# 字符作为换行符 first =

-----------------------*/ fdisk+item*DISKSIZE+u_opentable. char Space = 32; openitem[fd].size%DISKSIZE;

char Endter= '\n';

/* -----如果最后磁盘块剩余的大

for(i=0;i

{ -------*/

if(buf[i] == '$') if(DISKSIZE-u_opentable.openi

buf[i] = Space; tem[fd].size%DISKSIZE>len)

else if(buf[i] == '#') {

buf[i] = Endter; strcpy(first,buf);

}

u_opentable.openitem[fd].size

/*----------读取用户打开表对=

应表项第一个盘块号u_opentable.openitem[fd].size+le-----------------------*/ n;

item = cur_dir-

>directitem[temp].sizu_opentable.openitem[fd].firstdie = sk; cur_dir->directitem[temp].size+l

en;

/*-------------找到当前目录所 }

对应表项的序号 else

-------------------------*/ {

for(i=2;i

{ for(i=0;i<(DISKSIZE-u_opentab

le.openitem[fd].size%DISKSIZE);i

if(cur_dir->directitem[i].fir++)

stdisk==item) {/*写一部分内容到最后一块

break; 磁盘块的剩余空间(字节)*/

} first[i] = buf [i];

temp = i; /*-存放当前目录项的 }

/*-----计算分配完最后一块=buf[k];

磁盘的剩余空间(字节) 还剩下多少 }

字节未存储-------*/

ilen1 = fat[item].item = i; len-(DISKSIZE-u_opentable.openit--找到一块后将它的序号存放在上/*

em[fd].size%DISKSIZE); 一块的指针中-*/

ilen2 = ilen1/DISKSIZE; fat[i].em_disk = '1';

modlen = ilen1%DISKSIZE; --置找到的磁盘快的空闲标志位为/*

if(modlen>0) 已分配-*/

ilen2 = ilen2+1; /*-- fat[i].item = -1; /*--还需要多少块磁盘块-*/ 它的指针为 -1 (即没有下一块)-*/

}

for(j=0;j

{

u_opentable.openitem[fd].size

for(i=ROOT_DISK_NO+1;i

UM;i++)/*寻找空闲磁盘块*/ u_opentable.openitem[fd].size+le

n; {

cur_dir->directitem[temp].siz if(fat[i].em_disk=='0')

break; e =

} cur_dir->directitem[temp].size+l

if(i>=DISK_NUM) /*--如en;

果磁盘块已经分配完了-*/ }

return(-1); return 0;

first = }

fdisk+i*DISKSIZE; /*--找到的那块

空闲磁盘块的起始地址-*/ int read(int fd, char *buf)

if(j==ilen2-1) /*--如{

果是最后要分配的一块-*/ int len =

{ u_opentable.openitem[fd].size;

char *first;

for(k=0;k

ntable.openitem[fd].size%DISKSIZ int ilen1, modlen; E)-j*DISKSIZE;k++) first[k] = item =

buf[k]; u_opentable.openitem[fd].firstdi

} sk;

else/*-如果不是要最后

分配的一块--*/

{ ilen1 = len/DISKSIZE;

modlen = len%DISKSIZE;

for(k=0;k

first[k] ilen1 = ilen1+1; /*--计算

文件所占磁盘的块数-*/ 项的序号,供释放目录中-*/

first = fdisk+item*DISKSIZE; if(i>=MSD+2) /*--如果不在当前

/*--计算文件的起始位置-*/ 目录中-*/

return(-1);

for(i=0;i

{ if(cur_dir->directitem[cur_it

if(i==ilen1-1) /*--如果在em].property!='0') /*--如果删除的

最后一个磁盘块-*/ (不)是目录-*/

{ return(-3);

for(j=0;j

buf[i*DISKSIZE+j] = 文件打开,则不能删除,退出-*/

first[j]; {

}

else /*--不在最后一块磁盘 if(!strcmp(u_opentable.openit块-*/ em[i].name,name))

{ return(-2);

}

for(j=0;j

cur_dir->directitem[cur_item].fi buf[i*DISKSIZE+j] =

first[j]; rstdisk;/*--该文件的起始盘块号

item = fat[item].item; -*/

/*-查找下一盘块-*/ while(item!=-1) /*--释放空间,

first = 将FAT表对应项进行修改-*/

fdisk+item*DISKSIZE; {

} temp = fat[item].item;

} fat[item].item = -1;

return 0; fat[item].em_disk = '0'; } item = temp;

}

int del(char *name) /*-----------------释放目录项

{ -----------------------*/

int i,cur_item,item,temp; cur_dir->directitem[cur_item]

.sign = 0;

for(i=2;idirectitem[cur_item]要删除文件是否在当前目录中-*/ .firstdisk = -1;

{ strcpy(u_opentable.openitem[c

ur_item].name,"");

if(!strcmp(cur_dir->directite

m[i].name,name)) cur_dir->directitem[cur_item].ne

break; xt = -1;

}

cur_item = i; /*--用来保存目录cur_dir->directitem[cur_item].pr operty = '0'; {

cur_dir->directitem[cur_item] if(fat[j].em_disk=='0') .size = 0; break;

}

if(j>=DISK_NUM) return 0;

} return(-5);

fat[j].em_disk='1'; /*-将该空

int mkdir(char *name) 闲块设置为已分配-*/

{

int i,j; /*-------------填写目录项

struct direct *cur_mkdir; ----------*/

strcpy(cur_dir->directitem[i]

if(!strcmp(name,".")) .name,name);

return(-4); cur_dir->directitem[i].firstd

if(!strcmp(name,"..")) isk=j;

return(-4); cur_dir->directitem[i].size=R

if(strlen(name)>8) /*-如果目OOT_DISK_SIZE;

8位-*/ 录名长度大于 cur_dir->directitem[i].next=j

return(-1); ;

cur_dir->directitem[i].proper

for(i=2;i

有空闲目录项退出-*/

{

/*-所创目录在虚拟磁盘上的地址

if(cur_dir->directitem[i].fir(内存物理地址)-*/

stdisk==-1) cur_mkdir=(struct direct

break; *)(fdisk+cur_dir->directitem[i].

} firstdisk*DISKSIZE);

if(i>=MSD+2) /*-目录/文件已

满-*/ /*-初始化目录-*/

return(-2); /*-指向当前目录的目录项-*/

for(j=2;jdirectitem[0].sign是否有重名-*/ =0;

{ cur_mkdir->directitem[0].firs

tdisk=cur_dir->directitem[i].fir

if(!strcmp(cur_dir->directitestdisk;

m[j].name,name)) strcpy(cur_mkdir->directitem[

break; 0].name,".");

} cur_mkdir->directitem[0].next

if(jdirectitem[0].firstd

return(-3); isk;

for(j=ROOT_DISK_NO+1;jdirectitem[0].propUM;j++) /*-找到空闲磁盘块 j 后退erty='1';

出-*/ cur_mkdir->directitem[0].size

=ROOT_DISK_SIZE; int i,j,item;

struct direct *temp_dir;

/*-指向上一级目录的目录项-*/ /*-检查当前目录项中有无该目录

cur_mkdir->directitem[1].sign-*/

=cur_dir->directitem[0].sign; for(i=2;i

cur_mkdir->directitem[1].firs {

tdisk=cur_dir->directitem[0].fir

stdisk; if(!strcmp(cur_dir->directite

strcpy(cur_mkdir->directitem[m[i].name,name))

1].name,".."); break;

cur_mkdir->directitem[1].next }

=cur_mkdir->directitem[1].firstd if(i>=MSD+2) /*-没有这个文件

isk; 或目录-*/

cur_mkdir->directitem[1].prop return(-1);

erty='1'; if(cur_dir->directitem[i].pro

cur_mkdir->directitem[1].sizeperty!='1')/*-删除的不是目录-*/

=ROOT_DISK_SIZE; return(-3);

for(i=2;i

录都初始化为空-*/ /*-判断要删除的目录有无子目录

{ -*/

cur_mkdir->directitem[i].sign temp_dir=(struct direct =0;

*)(fdisk+cur_dir->directitem[i].

next*DISKSIZE);

cur_mkdir->directitem[i].firs for(j=2;jdirectitem[ if(temp_dir-

>directitem[j].nei].name,""); xt!=-1)

break;

cur_mkdir->directitem[i].next }

=-1; if(j

件-*/

cur_mkdir->directitem[i].prop return(-2);

erty='0'; /*------------找到起始盘块号,

并将其释放----------------*/

cur_mkdir->directitem[i].size item=cur_dir->directitem[i].f=0; irstdisk;

} fat[item].em_disk='0';

return 0; /*-修改目录项-*/

} cur_dir->directitem[i].sign=0

;

int rmdir(char *name) cur_dir->directitem[i].firstd{ isk=-1;

strcpy(cur_dir->directitem[i] str=name;

.name,"");

cur_dir->directitem[i].next=- if(!strcmp("\\",name)) 1; {

cur_dir->directitem[i].proper cur_dir = root; ty='0';

cur_dir->directitem[i].size=0 strcpy(bufferdir,"Root:"); ; return 0;

}

return 0;

} temp = (char

*)malloc(DIR_MAXSIZE*sizeof(charvoid dir() ));/*-最长路径名字分配空

间-*/ {

int i; for(i=0;i<(int)strlen(str);i+

for(i=2;i

{ temp[i]=str[i];

temp[i]='\0';

if(cur_dir->directitem[i].fir

for(j=0;j

该子目录是否在当前目录中-*/ {

{

printf("%s\t",cur_dir->direct

item[i].name); if(!strcmp(temp_dir->directit

em[j].name,temp))

if(cur_dir->directitem[i].pro break;

perty=='0') /*-文件-*/ }

printf("%d\t\t\n",cur_dir->di free(temp);/*释放申请的临时空

rectitem[i].size); 间*/

else //if(temp_dir->directitem[j].

printf("\t<目property!='1') /*-打开的不是目录