基于Linux的模拟文件系统的设计与实现

中北大学

操作系统课程设计

说明书

学院、系：软件学院

专业：软件工程

学生姓名：任彬学号：0921010132 设计题目：基于Linux的模拟文件系统的设计与实现

起迄日期: 2011年12月22日- 2012年1月7日指导教师:康珺

2012 年 1月 7 日

1.需求分析

本次课程设计题目为“基于Linux的模拟文件系统的设计与实现”，要求在linux开源环境下，通过使用系统库函数以及操作命令，模拟实现典型文件系统，实现文件的各项基本操作，以此加深对所学文件操作的了解以及操作方法的特点。通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识，加深教材中的重要算法的理解，同时通过编程实现这些算法，更好地掌握操作系统的远离及实现方法，提高综合运用各专业课知识的能力。根据实验要求可将系统功能简述如下：

（1）设计一个10个用户的文件系统。每个用户最多可以保存10个文件，一次运行用户可打开多个文件。

（2）程序采用二级文件目录。（即设置主目录（MFD）和用户文件目录（UFD））。另外，可打开文件设置指针。

（3）为了方便实现，对文件的读写作了简化。在执行读写命令时，只需改读写指针。并不进行实际的读写操作。

（4）实现目录的相关操作：改变目录（CD），创建目录（MD），显示目录（DIR），删除目录（RD）。

（5）实现文件的相关操作：打开文件（open），关闭文件（close），创建一个新文件（create），删除一个文件（delete），写文件（write），读文件（read）。

（6）考虑特殊情况如：目录不存在时，给出错误信息；不能用cd进入文件；命令之中不能有空格（如ex it，给出错误提示）；新建目录或文件时的问题、重名问题、目录或文件的名字长度限制、目录或文件的名字中包含不合法字符（注意空格）、删除目录或文件时的问题、删除不存在的文件或目录给出错误提示、删除目录时目录不为空（如果该目录为空，则可删除，否则给出是否做删除提示，删除操作将该目录下的全部文件和子目录都删除）、进入到某个目录下，却要删除本目录或上级目录、不能用delete删除目录、不能用RD删除文件等。.

2.总体设计

本系统以C语言为编程基础，通过调用linux环境下的库函数实现各功能模块。

<1>整个系统采用“主函数-子函数”结构。系统初始化无误后，运行主函数，在主函数中通过输入参数的变化调用相关功能子函数。各子函数之间采用平行结构，只与主函数有联系，整个系统共由17个子模块实现。

系统流程图如下：

各模块按功能可分为三类：

（1）文件初始化。void initfile()（初始化文件系统）; void format()(格式化); void enter()(进入文件系统)。

（2）目录管理。int create(char *name) (创建文件); int open(char *name) (打开文件); int close(char *name) (关闭文件); int write(int fd,char *buf,int len) (读文件); int read(int fd,char *buf) (读文件); int del(char *name) (删除文件)。

（3）文件管理。int mkdir(char *name) (创建子目录); int rmdir(char *name) (删除子目录); void dir()(显示当前目录的子目录); int cd(char *name) (更改当前目录); void print()(显示当前路径); void show()(输出提示信息)。<2>为实现文件的模拟访问以及控制，利用disk.dat虚拟磁盘的管理调度，保存运行过程中各项操作以及数据。各个子函数在功能实现时，首先必须利用相应指针定位到disk.dat文件，操作完成后将运行参数保存到文件中。

<2>结构体设计

(1)二级目录实现。为实现二级目录，定义如下结构体变量file，content。

typedef struct file{

char name[10];

struct file *next;

}File;

file结构体用于保存文件名，并通过指向下一个文件的指针形成单向链表。

typedef struct content{

char name[10];

File *file;

int f_num;

struct content *next;

}Content;

Content结构体用于保存目录名，此外，一方面通过指向下一个目录的指针形成单向链表，另一方面通过指向下一级的文件指针实现连接该目录头文件的作用，以此实现二级目录索引。

（2）用户访问实现。为实现用户访问，定义如下结构体user。

typedef struct user{

char name[10];

char psw[10];

Content *con;

struct user *next;

user结构体用于保存用户名和密码，通过指向下一个用户的指针将注册用户形成单向链表。用户登录时，进行用户名、密码的判断，若正确，跳转到主界面，否则通过指针的链接到下一个用户信息，重复上述过程。

（3）虚拟磁盘管理的实现。为实现虚拟磁盘的管理调度，定义结构体fatitem，direct，opentable。

struct fatitem /* size 8*/

{

int item; /*存放文件下一个磁盘的指针*/

char em_disk; /*磁盘块是否空闲标志位0 空闲*/

};

Fatitem结构体用于文件配置表fat表的结构定义。

struct direct

{

struct FCB

{

char name[9]; /*文件/目录名8位*/

char property; /*属性1位目录0位普通文件*/

int size; /*文件/目录字节数、盘块数)*/

int firstdisk; /*文件/目录起始盘块号*/

int next; /*子目录起始盘块号*/

int sign; /*1是根目录0不是根目录*/

}directitem[MSD+2];

-};

direct结构体用于目录项结构的定义，其中嵌套的FCB用于文件控制块的定义。

struct opentable

{

struct openttableitem

{

char name[9]; /*文件名*/

int firstdisk; /*起始盘块号*/

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

}openitem[MOFN];

int cur_size; /*当前打文件的数目*/

};

Opentable结构体用于文件打开表项结构的定义。

3.详细设计

结构化程序设计的模式是自顶向下，逐步求精的过程。当设计一个程序时，需要将需要将求解问题逐步分解成能解决局部问题的更小的功能模块，直到每一个局部模块都不能再分为止，每一个最小化的模块对应一个相应的函数。函数的功能应该最小化，即每个函数只完成一个简单的功能。根据模块功能能最小化的思想，我们将程序划分为17个子模块，每个模块只负责完成一个功能，他们分别为void initfile()（初始化文件系统）; void format()(格式化); void enter()(进入文件系统); void halt()(退出文件系统); int create(char *name) (创建文件); int open(char *name) (打开文件); int close(char *name) (关闭文件); int write(int fd,char *buf,int len) (读文件); int read(int fd,char *buf) (读文件); int del(char *name) (删除文件); int mkdir(char *name) (创建子目录); int rmdir(char *name) (删除子目录); void dir()(显示当前目录的子目录); int cd(char *name) (更改当前目录); void print()(显示当前路径); void show()(输出提示信息)以及main函数。各个函数通过相互嵌套调用，最终完成实现linux下模拟文件的设计和实现。

(1)初始化文件系统：initfile()函数

主要源码为：

void initfile()

{

fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char));

format();

}

使用库函数Malloc 向系统申请分配指定size个字节的内存空间。，用来储存char类型文件，同时初始化文件。

(2)格式化文件：void format();

主要源码为：

void format()

{

int i;

FILE *fp;

fat = (struct fatitem *)(fdisk+DISKSIZE); /*计算FAT表地址，引导区向后偏移1k)*/

/*-----初始化FAT表------------*/

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

fat[0].em_disk='1';

for(i=1;i

{

fat[i].item=i+1;

fat[i].em_disk='1';

}

//fat[ROOT_DISK_NO-1].item=-1;

//fat[ROOT_DISK_NO-1].em_disk='1';

fat[ROOT_DISK_NO].item=-1; /*存放根目录的磁盘块号*/

fat[ROOT_DISK_NO].em_disk='1';

for(i=ROOT_DISK_NO+1;i

{

fat[i].item = -1;

fat[i].em_disk = '0';

}

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

root = (struct direct *)(fdisk+DISKSIZE+FATSIZE); /*根目录的地址*/ /*初始化目录*/

/*---------指向当前目录的目录项---------*/

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

root->directitem[0].firstdisk = ROOT_DISK_NO;

strcpy(root->directitem[0].name,".");

root->directitem[0].next = root->directitem[0].firstdisk;

root->directitem[0].property = '1';

root->directitem[0].size = ROOT_DISK_SIZE;

/*-------指向上一级目录的目录项---------*/

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

root->directitem[1].firstdisk = ROOT_DISK_NO;

strcpy(root->directitem[1].name,"..");

root->directitem[1].next = root->directitem[0].firstdisk;

root->directitem[1].property = '1';

root->directitem[1].size = ROOT_DISK_SIZE;

if((fp = fopen("disk.dat","wb"))==NULL)

{

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

return;

}

for(i=2;i

{

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

root->directitem[i].firstdisk = -1;

strcpy(root->directitem[i].name,"");

root->directitem[i].next = -1;

root->directitem[i].property = '0';

root->directitem[i].size = 0;

}

if((fp = fopen("disk.dat","wb"))==NULL)

{

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

return;

}

if(fwrite(fdisk,MEM_D_SIZE,1,fp)!=1) /*把虚拟磁盘空间保存到磁盘文件中*/

{

printf("Error:\n File write error! \n");

}

fclose(fp);

}

本函数用来计算在程序中已定义的struct fatitem *fat; /*FAT表*/ struct direct *root; /*根目录*/；struct direct *cur_dir; /*当前目录*/的地址及对他们进行初始化，方便以后的使用。通过指针定义的方法，将结构体中的成员进行定义。

(3)void enter()(进入文件系统);

主要源码为：

void enter()

{

FILE *fp;

int i;

fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请1M空间*/

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

{

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

return;

}

if(!fread(fdisk,MEM_D_SIZE,1,fp)) /*把磁盘文件disk.dat 读入虚拟磁盘空间(内存)*/

{

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

exit(0);

}

fat = (struct fatitem *)(fdisk+DISKSIZE); /*找到FAT表地址*/

root = (struct direct *)(fdisk+DISKSIZE+FATSIZE);/*找到根目录地址*/

fclose(fp);

/*--------------初始化用户打开表------------------*/

for(i=0;i

{

strcpy(u_opentable.openitem[i].name,"");

u_opentable.openitem[i].firstdisk = -1;

u_opentable.openitem[i].size = 0;

}

u_opentable.cur_size = 0;

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

bufferdir = (char *)malloc(DIR_LENGTH*sizeof(char));

strcpy(bufferdir,"Root:");

}

本函数完成进入文件系统的功能，首先定义一个文件指针并分配空间，然后进行if语句判断，以只读的方式打开二进制文件，如果无法打开，显示错误，打开成功，则检测把是否磁盘文件disk.dat 读入虚拟磁盘空间(内存)，失败同样显示错误，当两项条件句满足要求时，找到fat表地址，找到根目录地址，打开文件并显示目录。

(4) void halt()(退出文件系统);

主要源码为：

void halt()

{

FILE *fp;

int i;

if((fp=fopen("disk.dat","wb"))==NULL)

{

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

return;

}

if(!fwrite(fdisk,MEM_D_SIZE,1,fp)) /*把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat */

{

printf("Error:\nFile write error!\n");

}

fclose(fp);

free(fdisk);

free(bufferdir);

return;

}

本函数完成关闭文件的功能，与进入文件系统相同，首先定义一个文件指针并分配空间，然后进行if语句判断，是否建立了只允许写的文件disk.dat，如果文件不存在，显示错误，文件存在成功，则检测把是否把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat，失败同样显示错误，当两项条件句满足要求时，关闭文件，释放的缓存空间。

(5)int create(char *name) (创建文件)

主要源码为：

int create(char *name)

{

int i,j;

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

return(-1);

for(j=2;j

{

if(!strcmp(cur_dir->directitem[j].name,name))

break;

}

if(j

return(-4);

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk==-1)

break;

}

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

return(-2);

if(u_opentable.cur_size>=MOFN) /*打开文件太多*/

return(-3);

for(j=ROOT_DISK_NO+1;j

{

if(fat[j].em_disk=='0')

break;

}

if(j>=DISK_NUM)

return(-5);

fat[j].em_disk = '1'; /*将空闲块置为已经分配*/

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

strcpy(cur_dir->directitem[i].name,name);

cur_dir->directitem[i].firstdisk = j;

cur_dir->directitem[i].size = 0;

cur_dir->directitem[i].next = j;

cur_dir->directitem[i].property = '0';

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

fd = open(name);

return 0;

}

本函数实现创建文件的功能，首先进行条件判断，检测文件名长度，检测文件是否有重名，其中文件名不能超过八位，文件不能有重名。如果两项条件满足，则采用顺序法查找符合条件的空闲子目录，创建文件，用指针定义法将结构体定义，创建文件；如果没有空闲目录项或打开文件过多则返回一个错误的值。

(6)int open(char *name) (打开文件)

主要源码为：

int open(char *name)

{

int i, j;

for(i=2;i

{

if(!strcmp(cur_dir->directitem[i].name,name))

break;

}

if(i>=MSD+2)

return(-1);

/*--------是文件还是目录-----------------------*/

if(cur_dir->directitem[i].property=='1')

return(-4);

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

for(j=0;j

{

if(!strcmp(u_opentable.openitem[j].name,name))

break;

}

if(j

return(-2);

if(u_opentable.cur_size>=MOFN) /*文件打开太多*/

return(-3);

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

for(j=0;j

{

if(u_opentable.openitem[j].firstdisk==-1)

break;

}

/*--------------填写表项的相关信息------------------------*/

u_opentable.openitem[j].firstdisk = cur_dir->directitem[i].firstdisk;

strcpy(u_opentable.openitem[j].name,name);

u_opentable.openitem[j].size = cur_dir->directitem[i].size;

u_opentable.cur_size++;

/*----------返回用户打开表表项的序号--------------------------*/

return(j);

}

本函数用来实现打开文件的功能，首先检测输入的文件名是否存在，不存在，则不做任何运行，存在则继续下一步逻辑判断。接着检测输入的是文件名还是目录，是目录，返回一个错误的值，是文件名，则监测文件是否打开，打开则不作操作，未打开则寻找一个空闲用户，打开文件，返回打开文件的序号。

(7) int close(char *name) (关闭文件)

主要源码为：

int close(char *name)

{

int i;

for(i=0;i

{

if(!strcmp(u_opentable.openitem[i].name,name))

break;

}

if(i>=MOFN)

return(-1);

/*-----------清空该文件的用户打开表项的内容---------------------*/

strcpy(u_opentable.openitem[i].name,"");

u_opentable.openitem[i].firstdisk = -1;

u_opentable.openitem[i].size = 0;

u_opentable.cur_size--;

return 0;

}

本函数实现关闭文件的功能，同时清空该文件的用户打开表项的内容。

(8)int write(int fd,char *buf,int len) (读文件);

主要源码为：

int write(int fd, char *buf, int len)

{

char *first;

int item, i, j, k;

int ilen1, ilen2, modlen, temp;

/*----------用$ 字符作为空格# 字符作为换行符-----------------------*/

char Space = 32;

char Endter= '\n';

for(i=0;i

{

if(buf[i] == '$')

buf[i] = Space;

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

buf[i] = Endter;

}

/*----------读取用户打开表对应表项第一个盘块号-----------------------*/

item = u_opentable.openitem[fd].firstdisk;

/*-------------找到当前目录所对应表项的序号-------------------------*/

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk==item)

break;

}

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

/*------找到的item 是该文件的最后一块磁盘块-------------------*/

while(fat[item].item!=-1)

{

item =fat[item].item; /*-查找该文件的下一盘块--*/

}

/*-----计算出该文件的最末地址-------*/

first = fdisk+item*DISKSIZE+u_opentable.openitem[fd].size%DISKSIZE;

/*-----如果最后磁盘块剩余的大小大于要写入的文件的大小-------*/

if(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE>len)

{

strcpy(first,buf);

u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;

cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;

}

else

{

for(i=0;i<(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);i++)

{/*写一部分内容到最后一块磁盘块的剩余空间(字节)*/

first[i] = buf [i];

}

/*-----计算分配完最后一块磁盘的剩余空间(字节) 还剩下多少字节未存储-------*/ ilen1 = len-(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);

ilen2 = ilen1/DISKSIZE;

modlen = ilen1%DISKSIZE;

if(modlen>0)

ilen2 = ilen2+1; /*--还需要多少块磁盘块-*/

for(j=0;j

{

for(i=ROOT_DISK_NO+1;i

{

if(fat[i].em_disk=='0')

break;

}

if(i>=DISK_NUM) /*--如果磁盘块已经分配完了-*/

return(-1);

first = fdisk+i*DISKSIZE; /*--找到的那块空闲磁盘块的起始地址-*/

if(j==ilen2-1) /*--如果是最后要分配的一块-*/

{

for(k=0;k

}

else/*-如果不是要最后分配的一块--*/

{

for(k=0;k

first[k] =buf[k];

}

fat[item].item = i; /*--找到一块后将它的序号存放在上一块的指针中-*/

fat[i].em_disk = '1'; /*--置找到的磁盘快的空闲标志位为已分配-*/

fat[i].item = -1; /*--它的指针为-1 (即没有下一块)-*/

}

/*--修改长度-*/

u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;

cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;

}

return 0;

}

本函数用来实现写文件的功能。文件打开后，进行写操作，更改文件内容。首先检测写入的内容，检测是否存在$与#的字符，若有，则将$ 字符作为空格# 字符作为换行符。然后读取用户打开表对应表项第一个盘块号，找到当前目录所对应表项的序号，找到该文件的最后一块磁盘块，计算出文件的最末地址，计算写入文件大小，如果最后磁盘块剩余的大小大于要写入的文件的大小，则写入文件，如果最后磁盘块剩余的大小小于要写入的文件的大小，将磁盘写满后，计算出还剩下多少字节未存储，还需多少磁盘，在链表中寻找空闲磁盘块，继续写入剩余字节，找到后，记录此磁盘的首地址指针，写入文件，磁盘写满后将后一个磁盘的起始地址的指针放入到前一磁盘的指针中，完成文件的链接，就这样直到文件写完为止，最后修改文件长度。

(9) int read(int fd,char *buf) (读文件);

主要源码为：

int read(int fd, char *buf)

{

int len = u_opentable.openitem[fd].size;

char *first;

int i, j, item;

int ilen1, modlen;

item = u_opentable.openitem[fd].firstdisk;

ilen1 = len/DISKSIZE;

modlen = len%DISKSIZE;

if(modlen!=0)

ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/

first = fdisk+item*DISKSIZE; /*--计算文件的起始位置-*/

for(i=0;i

{

if(i==ilen1-1) /*--如果在最后一个磁盘块-*/

{

for(j=0;j

buf[i*DISKSIZE+j] = first[j];

}

else /*--不在最后一块磁盘块-*/

{

for(j=0;j

buf[i*DISKSIZE+j] = first[j];

item = fat[item].item; /*-查找下一盘块-*/

first = fdisk+item*DISKSIZE;

}

}

return 0;

}

本函数完成简单的磁盘读的功能，首先计算文件所占磁盘的块数，找到文件的起始位置，然后根据指针依次访问磁盘，完成整个文件的读功能。

(10) int del(char *name) (删除文件);

主要源码为：

int del(char *name)

{

int i,cur_item,item,temp;

for(i=2;i

{

if(!strcmp(cur_dir->directitem[i].name,name))

break;

}

cur_item = i; /*--用来保存目录项的序号,供释放目录中-*/

if(i>=MSD+2) /*--如果不在当前目录中-*/

return(-1);

if(cur_dir->directitem[cur_item].property!='0') /*--如果删除的(不)是目录-*/

return(-3);

for(i=0;i

{

if(!strcmp(u_opentable.openitem[i].name,name))

return(-2);

}

item = cur_dir->directitem[cur_item].firstdisk;/*--该文件的起始盘块号-*/

while(item!=-1) /*--释放空间,将FAT表对应项进行修改-*/

{

temp = fat[item].item;

fat[item].item = -1;

fat[item].em_disk = '0';

item = temp;

}

/*-----------------释放目录项-----------------------*/

cur_dir->directitem[cur_item].sign = 0;

cur_dir->directitem[cur_item].firstdisk = -1;

strcpy(u_opentable.openitem[cur_item].name,"");

cur_dir->directitem[cur_item].next = -1;

cur_dir->directitem[cur_item].property = '0';

cur_dir->directitem[cur_item].size = 0;

return 0;

}

本函数用来删除文件，首先检测要删除文件是否在当前目录中，无则返回错误信息，有则将文件的序号提供，查找文件地址，监测文件是否打开，如果打开，则提示文件已打开，无法删除，没打开则释放文件内存空间，释放目录项，同时修改Fat表。

(11) int mkdir(char *name) (创建子目录);

主要源码为：

int mkdir(char *name)

{

int i,j;

struct direct *cur_mkdir;

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

return(-4);

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

return(-4);

if(strlen(name)>8) /*-如果目录名长度大于8位-*/

return(-1);

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk==-1)

break;

}

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

return(-2);

for(j=2;j

{

if(!strcmp(cur_dir->directitem[j].name,name))

break;

}

if(j

return(-3);

for(j=ROOT_DISK_NO+1;j

if(fat[j].em_disk=='0')

break;

}

if(j>=DISK_NUM)

return(-5);

fat[j].em_disk='1'; /*-将该空闲块设置为已分配-*/

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

strcpy(cur_dir->directitem[i].name,name);

cur_dir->directitem[i].firstdisk=j;

cur_dir->directitem[i].size=ROOT_DISK_SIZE;

cur_dir->directitem[i].next=j;

cur_dir->directitem[i].property='1';

/*-所创目录在虚拟磁盘上的地址(内存物理地址)-*/

cur_mkdir=(struct direct *)(fdisk+cur_dir->directitem[i].firstdisk*DISKSIZE);

/*-初始化目录-*/

/*-指向当前目录的目录项-*/

cur_mkdir->directitem[0].sign=0;

cur_mkdir->directitem[0].firstdisk=cur_dir->directitem[i].firstdisk;

strcpy(cur_mkdir->directitem[0].name,".");

cur_mkdir->directitem[0].next=cur_mkdir->directitem[0].firstdisk;

cur_mkdir->directitem[0].property='1';

cur_mkdir->directitem[0].size=ROOT_DISK_SIZE;

/*-指向上一级目录的目录项-*/

cur_mkdir->directitem[1].sign=cur_dir->directitem[0].sign;

cur_mkdir->directitem[1].firstdisk=cur_dir->directitem[0].firstdisk;

strcpy(cur_mkdir->directitem[1].name,"..");

cur_mkdir->directitem[1].next=cur_mkdir->directitem[1].firstdisk;

cur_mkdir->directitem[1].property='1';

cur_mkdir->directitem[1].size=ROOT_DISK_SIZE;

for(i=2;i

{

cur_mkdir->directitem[i].sign=0;

cur_mkdir->directitem[i].firstdisk=-1;

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

cur_mkdir->directitem[i].next=-1;

cur_mkdir->directitem[i].property='0';

cur_mkdir->directitem[i].size=0;

}

return 0;

}

本函数用来实现创建子目录的功能，同文件的创建一样，目录名不得大于8位，且不得有重名。不满足则返回不同的值，如果条件满足，目录创建继续进行。寻找空闲目录，寻找空闲磁盘块，将空闲设置为已分配，创建子目录并初始化，同时计算所创目录在虚拟磁盘上的地址(内存物理地址)，指向当前目录的目录项，指向上一级目录的目录项。至此，子目录创建完成。

(12)int rmdir(char *name) (删除子目录);

主要源码为：

int rmdir(char *name)

{

int i,j,item;

struct direct *temp_dir;

/*-检查当前目录项中有无该目录-*/

for(i=2;i

{

if(!strcmp(cur_dir->directitem[i].name,name))

break;

}

if(i>=MSD+2) /*-没有这个文件或目录-*/

return(-1);

if(cur_dir->directitem[i].property!='1')/*-删除的不是目录-*/

return(-3);

/*-判断要删除的目录有无子目录-*/

temp_dir=(struct direct *)(fdisk+cur_dir->directitem[i].next*DISKSIZE);

for(j=2;j

{

if(temp_dir->directitem[j].next!=-1)

break;

}

if(j

return(-2);

/*------------找到起始盘块号,并将其释放----------------*/

item=cur_dir->directitem[i].firstdisk;

fat[item].em_disk='0';

/*-修改目录项-*/

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

cur_dir->directitem[i].firstdisk=-1;

strcpy(cur_dir->directitem[i].name,"");

cur_dir->directitem[i].next=-1;

cur_dir->directitem[i].property='0';

cur_dir->directitem[i].size=0;

return 0;

}

本函数用来删除子目录，首先检测要删除目录是否在当前目录中，无则返回错误信息，有则将目录的序号提供，删除目录，同时修改父目录项。

(13)void dir()(显示当前目录的子目录);

主要源码为：

void dir()

{

int i;

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk!=-1) /*-如果存在子目录-*/

{

printf("%s\t",cur_dir->directitem[i].name);

if(cur_dir->directitem[i].property=='0') /*-文件-*/

printf("%d\t\t\n",cur_dir->directitem[i].size);

else

printf("\t<目录>\t\n");

}

}

}

通过顺序法显示当前目录子目录。

(14) int cd(char *name) (更改当前目录);

主要源码为：

int cd(char *name)

{

int i,j,item;

char *str;

char *temp,*point,*point1;

struct direct *temp_dir;

temp_dir=cur_dir;

str=name;

if(!strcmp("\\",name))

{

cur_dir = root;

strcpy(bufferdir,"Root:");

return 0;