操作系统课程设计文件系统
操作系统课程设计-文件系统
操作系统课程设计-文件系统一、引言文件系统是操作系统中的重要组成部分，负责对计算机中的文件进行管理和组织。
在操作系统课程设计中，文件系统的设计和实现是一个重要的任务。
本文将介绍文件系统的设计原则、功能和实现过程。
二、设计原则1. 可靠性文件系统需要确保数据的可靠性，能够有效地进行错误检测和纠正。
它应该能够处理文件的损坏、删除或丢失等情况，并能够进行数据恢复。
2. 效率文件系统需要具备高效的存取和查找功能，能够在较短的时间内完成对文件的操作。
它应该对文件进行良好的组织和管理，以提高文件的读写速度。
3. 安全性文件系统要能够保护文件的机密性和完整性，确保只有授权用户才能访问文件，并防止数据被恶意篡改或破坏。
4. 可扩展性文件系统应该能够适应不同容量和规模的存储设备，并能够随着存储需求的增长而进行扩展。
三、功能1. 存储管理文件系统需要对存储设备进行管理，包括磁盘空间的分配、回收和整理等操作，确保文件能够高效地存储和读取。
2. 目录管理文件系统需要提供目录管理功能，能够对文件进行组织和分类。
用户可以根据目录结构查找和管理文件，方便文件的查找和访问。
3. 文件操作文件系统需要支持各种文件操作，包括创建、删除、打开、关闭、读取和写入等操作。
它应该提供一组接口供用户和应用程序使用。
4. 错误处理文件系统需要对各种错误情况进行处理，包括磁盘故障、读写错误和用户操作错误等。
它应该能够识别和纠正错误，并提供相应的错误提示和恢复机制。
四、实现过程1. 文件分配文件系统需要确定如何将磁盘空间分配给文件，以实现高效的存储和检索。
常见的文件分配方式包括连续分配、链式分配和索引分配等。
2. 目录结构文件系统需要设计合适的目录结构，以方便用户查找和管理文件。
常见的目录结构包括树状目录结构、索引节点和哈希表等。
3. 文件读写文件系统需要实现高效的文件读写功能，包括将文件从磁盘读入内存和将文件从内存写入磁盘。
它应该提供缓存机制来加速读写操作。
操作系统课程设计-文件系统
模拟一个简单二级文件管理系统设计目的：通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部功能和实现过程的理解。
设计内容：模拟一个简单二级文件管理系统一、实验内容描述1 实验目标本实验的目的是通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现.2 实验要求为DOS系统设计一个简单的二级文件系统.要求做到以下几点：①可以实现下列命令：login 用户登录dir 列文件目录create 创建文件delete 删除文件open 打开文件close 关闭文件read 读文件write 写文件②列目录时要列出文件名、物理地址、保护码和文件长度.③源文件可以进行读写保护.二、程序主要内容1设计思路程序中要求每个用户在登陆后才可对其拥有的文件进行操作，用户对于其他用户的文件无操作权.文件操作包括浏览、创建、删除、打开、关闭、阅读、写入、修改模式.其他操作包括新建用户、帮助、用户登入、用户登出、退出系统.在程序文件夹下有个名为“file”的系统根目录，此目录下包括：一个名为“mfd”的文件，记录所有注册过的帐号及密码；用户文件，以用户名作为文件名，内容为其拥有的文件名及属性；一个名为“keiji”的文件夹.“keiji”文件夹中包括：“file.p”指针文件，记录所有已用的物理地址；一些以物理地址为名的文件，内容为文件内容.2 数据结构file结构体系统文件数据结构：fpaddrint，文件的物理地址、flengthint，文件长度、fmodeint，文件模式0.只读；1.可写；2.可读写；3.保护、fname[]char，文件名；filemode结构体文件状态数据结构：isopenint，文件当前状态，0.关闭；1.打开、modeint，文件模式0.只读；1.可写；2.可读写；3.初始化；user结构体用户信息数据结构：uname[]char，用户名、upassword[]char，用户密码；userfile结构体用户文件数据结构：uname[]char，用户名、ufile[]file，用户拥有的文件数组.代码：#include <stdio.h>#include <stdlib.h>#include <conio.h>#include <time.h>#include <string.h>#define MaxUser 100 //定义最大MDF主目录文件#define MaxDisk 512*1024 //模拟最大磁盘空间#define commandAmount 12 //对文件操作的指令数//存储空间管理有关结构体和变量char disk[MaxDisk]; //模拟512K的磁盘存储空间typedef struct distTable //磁盘块结构体{int maxlength;int start;int useFlag;distTable *next;}diskNode;diskNode *diskHead;struct fileTable //文件块结构体{char fileName[10];int strat; //文件在磁盘存储空间的起始地址int length; //文件内容长度int maxlength; //文件的最大长度char fileKind[3]; //文件的属性——读写方式struct tm *timeinfo;bool openFlag; //判断是否有进程打开了该文件//fileTable *next;};//两级目录结构体typedef struct user_file_directory //用户文件目录文件UFD {//char fileName[10];fileTable *file;user_file_directory *next;}UFD;//UFD *headFile;typedef struct master_file_directory //主文件目录MFD{char userName[10];char password[10];UFD *user;}MFD;MFD userTable[MaxUser];int used=0; //定义MFD目录中用已有的用户数//文件管理void fileCreate(char fileName[],int length,char fileKind[]); //创建文件void fileWrite(char fileName[]); //写文件void fileCat(char fileName[]); //读文件void fileRen(char fileName[],char rename[]); //重命名文件void fileFine(char fileName[]); //查询文件void fileDir(char UserName[]); //显示某一用户的所有文件void fileClose(char fileName[]); //关闭已打开的文件void fileDel(char fileName[]); //删除文件void chmod(char fileName[],char kind[]); //修改文件的读写方式int requestDist(int &startPostion,int maxLength); //磁盘分配查询void initDisk(); //初始化磁盘void freeDisk(int startPostion); //磁盘空间释放void diskShow(); //显示磁盘使用情况//用户管理void userCreate();int login();int userID=-1; //用户登录的ID号，值为-1时表示没有用户登录int main(){char order[commandAmount][10];strcpy(order[0],"create");strcpy(order[1],"rm");strcpy(order[2],"cat");strcpy(order[3],"write");strcpy(order[4],"fine");strcpy(order[5],"chmod");strcpy(order[6],"ren");strcpy(order[7],"dir");strcpy(order[8],"close");printf("————————————————————————————————————————\n");printf("please imput your command:>");gets(command);int select;for(i=0;command[i]!=' '&&command[i]!='\0';i++) //command_str1字符串存储命令的操作类型command_str1[i]=command[i];k=i;command_str1[k]='\0';for(i=0;i<commandAmount;i++){if(!strcmp(command_str1,order[i])){select=i;break;}}if(i==commandAmount){printf("您输入的命令有误，请重新输入\n");continue;}for(i=k+1,k=0;command[i]!=' '&&command[i]!='\0';i++,k++) //commmand_str2字符串存储文件名或用户名command_str2[k]=command[i];command_str2[k]='\0';k=i;switch(select){case 0:for(i=k+1,k=0;command[i]!=' ';i++,k++)command_str3[k]=command[i];command_str3[k]='\0';k=i;j=1;length=0; //初始化文件长度for(i=strlen(command_str3)-1;i>=0;i--) //把字符串转换为十进制{length+=(command_str3[i]-48)*j;j*=10;}for(i=k+1,k=0;command[i]!=' '&&command[i]!='\0';i++,k++)command_str4[k]=command[i];command_str4[k]='\0';fileCreate(command_str2,length,command_str4);break;case 1:fileDel(command_str2);break;case 2:fileCat(command_str2);break;case 3:fileWrite(command_str2);break;case 4:fileFine(command_str2);break;case 5:for(i=k+1,k=0;command[i]!=' '&&command[i]!='\0';i++,k++)command_str3[k]=command[i];command_str3[k]='\0';chmod(command_str2,command_str3);break;case 6:for(i=k+1,k=0;command[i]!='\0';i++,k++)command_str3[k]=command[i];command_str3[k]='\0';fileRen(command_str2,command_str3);break;case 7:fileDir(command_str2);break;case 8:fileClose(command_str2);break;case 9:UFD *p;for(p=userTable[userID].user->next;p!=NULL;p=p->next) //退出用户之前关闭所有打的文件if(p->file->openFlag)p->file->openFlag=false;system("cls");userID=-1;break;case 10:exit(0);break;case 11:diskShow();break;}}}return 0;}void userCreate(){char c;char userName[10];int i;if(used<MaxUser){printf("请输入用户名：");for(i=0;c=getch();i++){if(c==13) break;elseuserName[i]=c;printf("%c",c);}userName[i]='\0';for(i=0;i<used;i++){if(!strcmp(userTable[i].userName,userName)){printf("\n");printf("该用户名已存在,创建用户失败\n");system("pause");return;}}strcpy(userTable[used].userName,userName);printf("\n");printf("请输入密码：");for(i=0;c=getch();i++){if(c==13) break;elseuserTable[used].password[i]=c;printf("*");}userTable[userID].password[i]='\0';printf("\n");printf("创建用户成功\n");used++;system("pause");}else{printf("创建用户失败，用户已达到上限\n");system("pause");}fflush(stdin);}int login(){char name[10],psw[10];char c;int i,times;printf("请输入用户名:");for(i=0;c=getch();i++){if(c==13) break;elsename[i]=c;printf("%c",c);}name[i]='\0';for(i=0;i<used;i++){if(!strcmp(userTable[i].userName,name))break;}if(i==used){printf("\n您输入的用户名不存在\n");system("pause");return -1;}for(times=0;times<3;times++){memset(psw,'\0',sizeof(psw));printf("\n请输入密码:");for(i=0;c=getch();i++){if(c==13) break;elsepsw[i]=c;printf("*");}printf("\n");for(i=0;i<used;i++){if(!strcmp(psw,userTable[i].password)){printf("用户登录成功\n");system("pause");break;}}if(i==used){printf("您输入的密码错误，您还有%d次输入机会\n",2-times);if(times==2) exit(0);}else break;}fflush(stdin);return i;}void initDisk(){diskHead=(diskNode *)malloc(sizeof(diskNode));diskHead->maxlength=MaxDisk;diskHead->useFlag=0;diskHead->start=0;diskHead->next=NULL;}int requestDist(int &startPostion,int maxLength){int flag=0; //标记是否分配成功diskNode *p,*q,*temp;p=diskHead;while(p){if(p->useFlag==0&&p->maxlength>maxLength){startPostion=p->start;q=(diskNode *)malloc(sizeof(diskNode));q->start=p->start;q->maxlength=maxLength;q->useFlag=1;q->next=NULL;diskHead->start=p->start+maxLength;diskHead->maxlength=p->maxlength-maxLength;flag=1;temp=p;if(diskHead->next==NULL) diskHead->next=q;else{while(temp->next) temp=temp->next;temp->next=q;}break;}p=p->next;}return flag;}void fileCreate(char fileName[],int length,char fileKind[]){//int i,j;time_t rawtime;int startPos;UFD *fileNode,*p;for(p=userTable[userID].user->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName)){printf("文件重名，创建文件失败\n");system("pause");return;}}if(requestDist(startPos,length)){fileNode=(UFD *)malloc(sizeof(UFD));fileNode->file=(fileTable *)malloc(sizeof(fileTable)); //这一步必不可少，因为fileNode里面的指针也需要申请地址，否则fileNode->file指向会出错strcpy(fileNode->file->fileName,fileName);strcpy(fileNode->file->fileKind,fileKind);fileNode->file->maxlength=length;fileNode->file->strat=startPos;fileNode->file->openFlag=false;time(&rawtime);fileNode->file->timeinfo=localtime(&rawtime);fileNode->next=NULL;if(userTable[userID].user->next==NULL)userTable[userID].user->next=fileNode;else{p=userTable[userID].user->next;while(p->next) p=p->next;p->next=fileNode;}printf("创建文件成功\n");system("pause");}{printf("磁盘空间已满或所创建文件超出磁盘空闲容量，磁盘空间分配失败\n");system("pause");}}void freeDisk(int startPostion){diskNode *p;for(p=diskHead;p!=NULL;p=p->next){if(p->start==startPostion)break;}p->useFlag=false;}void fileDel(char fileName[]){UFD *p,*q,*temp;q=userTable[userID].user;p=q->next;while(p){if(!strcmp(p->file->fileName,fileName)) break;else{p=p->next;q=q->next;}}if(p){if(p->file->openFlag!=true) //先判断是否有进程打开该文件{temp=p;q->next=p->next;freeDisk(temp->file->strat); //磁盘空间回收free(temp);printf("文件删除成功\n");system("pause");}elseprintf("该文件已被进程打开,删除失败\n");system("pause");}}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void fileCat(char fileName[]){int startPos,length;int k=0;UFD *p,*q;q=userTable[userID].user;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){startPos=p->file->strat;length=p->file->length;p->file->openFlag=true; //文件打开标记printf("*****************************************************\n");for(int i=startPos;k<length;i++,k++){if(i%50==0) printf("\n"); //一行大于50个字符换行printf("%c",disk[i]);}printf("\n\n*****************************************************\n");printf("%s已被read进程打开,请用close命令将其关闭\n",p->file->fileName);system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void fileWrite(char fileName[]){UFD *p,*q;q=userTable[userID].user;int i,k,startPos;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){if(!strcmp(p->file->fileKind,"r")) //判断文件类型{printf("该文件是只读文件,写入失败\n");system("pause");return;}char str[500];printf("please input content:\n");gets(str);startPos=p->file->strat;p->file->openFlag=true; //文件打开标记p->file->length=strlen(str);if(p->file->length>p->file->maxlength){printf("写入字符串长度大于该文件的总长度,写入失败\n");system("pause");return;}for(i=startPos,k=0;k<(int)strlen(str);i++,k++)disk[i]=str[k];printf("文件写入成功,请用close命令将该文件关闭\n");system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void fileFine(char fileName[])UFD *p,*q;q=userTable[userID].user;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){printf("********************************************\n");printf("文件名：%s\n",p->file->fileName);printf("文件长度：%d\n",p->file->maxlength);printf("文件在存储空间的起始地址：%d\n",p->file->strat);printf("文件类型：%s\n",p->file->fileKind);printf("创建时间：%s\n",asctime(p->file->timeinfo));printf("********************************************\n");system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void chmod(char fileName[],char kind[]){UFD *p,*q;q=userTable[userID].user;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){strcpy(p->file->fileKind,kind);printf("修改文件类型成功\n");system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void fileRen(char fileName[],char name[]){UFD *p,*q;q=userTable[userID].user;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){while(q->next){if(!strcmp(q->next->file->fileName,name)){printf("您输入的文件名已存在,重命名失败\n");system("pause");return;}q=q->next;}strcpy(p->file->fileName,name);printf("重命名成功\n");system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}void fileDir(char userName[]){UFD *p;int i,k;for(i=0;i<MaxUser;i++){if(!strcmp(userTable[i].userName,userName)){k=i;break;}}if(i==MaxUser){printf("没有找到该用户，请检查输入用户名是否正确\n");system("pause");return;}else{p=userTable[k].user->next;printf("************************************************************************* *******\n");printf("文件名文件长度文件在磁盘的起始地址文件类型创建时间\n");for(;p!=NULL;p=p->next)printf("%s %d %d %s %s",p->file->fileName, p->file->maxlength,p->file->strat,p->file->fileKind,asctime(p->file->timeinfo));printf("************************************************************************* *******\n");system("pause");}}void diskShow(){diskNode *p;int i=0,unusedDisk=0;printf("************************************************************************* **\n");printf(" 盘块号起始地址容量(bit) 是否已被使用\n");for(p=diskHead;p!=NULL;p=p->next,i++){if(p->useFlag==false) unusedDisk+=p->maxlength;printf(" %d %d %d %d \n",i,p->start,p->maxlength,p->useFlag);}printf("************************************************************************* **\n");printf("磁盘空间总容量：512*1024bit 已使用：%dbit 末使用：%dbit\n\n",MaxDisk-unusedDisk,unusedDisk);system("pause");}void fileClose(char fileName[]){UFD *p,*q;q=userTable[userID].user;for(p=q->next;p!=NULL;p=p->next){if(!strcmp(p->file->fileName,fileName))break;}if(p){p->file->openFlag=false;printf("%s文件已关闭\n",p->file->fileName);system("pause");}else{printf("没有找到该文件,请检查输入的文件名是否正确\n");system("pause");}}运行结果视图：(略)。
操作系统课程设计文件管理系统
操作系统课程设计文件管理系统1. 引言文件管理是操作系统中的一个重要模块，负责对计算机中的文件进行管理和组织。
在操作系统课程设计中，设计一个文件管理系统是一个很有挑战性的任务，需要考虑到文件的创建、打开、读取、写入、删除等功能，并且要确保文件的安全性和可靠性。
本文将详细介绍文件管理系统的设计与实现。
2. 需求分析为了满足用户对文件管理的需要，我们需要对文件管理系统的需求进行分析。
在这个文件管理系统中，用户应该能够执行以下操作：•文件的创建和命名•文件的打开和关闭•文件的读取和写入•文件的删除和修改•文件的搜索和查找除此之外，还要考虑到对文件权限的管理，可以设置不同用户对文件的不同访问权限，以保障文件的安全性。
3. 概要设计概要设计是对文件管理系统的整体架构和功能进行规划和设计。
文件管理系统可以采用层次结构的设计方式，分为用户界面、文件管理模块和存储管理模块。
3.1 用户界面用户界面是用户与文件管理系统进行交互的接口，可以通过命令行或者图形界面来实现。
在用户界面中，用户可以输入相关指令来执行对文件的操作，如创建文件、打开文件、读取文件等。
3.2 文件管理模块文件管理模块是文件管理系统的核心模块，负责对文件进行创建、打开、读取、写入、删除等操作。
在文件管理模块中，需要维护一个文件目录表来记录文件的基本信息，如文件名、文件大小、文件权限等。
还需要考虑到文件的分配和回收，可以使用位示图等方式进行实现。
3.3 存储管理模块存储管理模块负责对文件进行存储和管理，包括磁盘空间的分配和回收。
在存储管理模块中，可以采用文件分配表或者索引节点进行存储方式的选择。
4. 详细设计在详细设计阶段，需要对概要设计中的每个模块进行详细设计，并确定各个模块之间的接口和数据结构。
4.1 用户界面设计用户界面设计可以采用命令行方式进行实现。
用户可以通过命令输入来执行相应的文件管理操作。
可以设计一系列命令，如create用于创建文件，open用于打开文件，read用于读取文件等。
操作系统课程设计-文件系统目录管理
文件管理系统——目录文件管理的设计目录第一章课程设计目的和要求 (1)1 课程设计目的 (1)2 课程设计要求 (1)2.1 课程设计思想原理 (1)2.2 课程题目 (1)2.3 提交课程设计报告 (2)第二章课程设计内容 (3)1 文件管理系统结构 (3)2 文件系统采用索引文件结构 (3)2.1 磁盘模拟 (3)2.2文件的逻辑结构 (3)2.3目录结构 (3)2.4用户接口 (5)第三章详细设计 (7)1 程序功能模块图 (7)2 实体关系图 (7)3 数据流图 (8)4 数据结构设计 (8)5 程序流程图 (11)5.1 建立文件目录(mkdir)程序流程图 (11)5.2 删除文件目录(rmdir)程序流程图 (12)第四章程序运行与测试 (13)1 程序运行主界面 (13)2 用mkdir [dirname] 命令创建子目录 (13)3用ls命令显示当前目录下信息 (13)4 用rmdir [dirname] 命令删除子目录 (14)5 用cd [dirname] 命令改名当前目录 (14)第五章课程设计总结 (16)附录Ⅰ参考文献 (17)附录Ⅱ程序清单 (18)第一章课程设计目的和要求1 课程设计目的操作系统课程主要讲述的内容是多道操作系统的原理与技术，与其它计算机原理、编译原理、汇编语言、计算机网络、程序设计等专业课程关系十分密切。
本课程设计的目的综合应用学生所学知识，建立系统和完整的计算机系统概念，理解和巩固操作系统基本理论、原理和方法，掌握操作系统开发的基本技能。
通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识, 加深对教材中的重要算法的理解。
同时通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。
2 课程设计要求2.1 课程设计思想原理阅读操作系统方面的书籍，了解操作系统的文件系统原理。
结合分析课程设计要求，确定实体以及它们之间的关系。
操作系统课程设计二级文件系统
操作系统课程设计报告专业：计算机信息处理学号：08201328姓名：杨馨雨提交日期：2011-7-14【设计目的】1.课程设计目的是通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能和内部实现。
2.结合数据结构、程序设计、计算机原理等课程的知识，设计一个二级文件系统，进一步理解操作系统。
3.通过对实际问题的分析、设计、编程实现，提高学生实际应用、编程的能力【设计内容】1、delete删除文件2、open打开文件3、close关闭文件4、write写文件【实验环境】Windows7系统Visualstudio2010【相关知识综述】本文件系统采用两级目录，其中第一级对应于用户账号，第二级对应于用户帐号下的文件。
另外，为了简便文件系统未考虑文件共享，文件系统安全以及管道文件与设备文件等特殊内容。
首先应确定文件系统的数据结构：主目录、子目录及活动文件等。
主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。
用户创建的文件，可以编号存储于磁盘上。
如：file0,file1,file2…并以编号作为物理地址，在目录中进行登记。
【设计思路】1主要数据结构#define MAXNAME25/*thelargestlengthofmfdname,ufdname,filename*/#define MAXCHILD50/*thelargestchild每个用户名下最多有50个文件*/#define MAX(MAXCHILD*MAXCHILD)/*thesizeoffpaddrno*/typedefstruct/*thestructureofOSFILE定义主文件*/{int fpaddr;/*filephysicaladdress*/int flength;/*filelength*/int fmode;/*filemode:0-ReadOnly;1-WriteOnly;2-ReadandWrite;3-Protect;*/char fname[MAXNAME];/*filename*/}OSFILE;typedefstruct/*thestructureofOSUFD定义用户文件目录*/{char ufdname[MAXNAME];/*ufdname*/OSFILEufdfile[MAXCHILD];/*ufdownfile*/}OSUFD;typedefstruct/*thestructureofOSUFD'LOGIN定义登陆*/{char ufdname[MAXNAME];/*ufdname*/char ufdpword[8];/*ufdpassword*/}OSUFD_LOGIN;typedefstruct/*fileopenmode定义操作方式*/{int ifopen;/*ifopen:0-close,1-open*/int openmode;/*0-readonly,1-writeonly,2-readandwrite,3-initial*/}OSUFD_OPENMODE;2主要函数void LoginF();/*LOGINFileSystem*/void DirF();/*DirFileSystem*/void CreateF();/*CreateFile*/void DeleteF();/*DeleteFile*/void ModifyFM();/*ModifyFileMode*/void OpenF();/*OpenFile*/void CloseF();/*CloseFile*/void ReadF();/*ReadFile*/void WriteF();/*WriteFile*/void QuitF();/*QuitFileSystem*/void CdF();/*ChangeDir*/void help();【主要程序段】1Delete函数voidDeleteF()/*DeleteFile*/{charfname[MAXNAME],str[50],str1[50];inti,k,j;intfpaddrno1;if(strcmp(strupr(ltrim(rtrim(dirname))),"")==0)/*无法删除主目录的文件*/{printf("\.\n");wgetchar=1;}if(strcmp(strupr(dirname),strupr(username))!=0)/*无法删除非自己目录的文件*/{printf("\.\n");wgetchar=1;}else{printf("\nPleaseinputFileName:");gets(fname);fopen==1)/*文件打开时无法删除*/{printf("\nError.\'%s\'.\n",fname);wgetchar=1;}else{if(ufd[k]->ufdfile[i].fmode==3)/*被保护的文件无法删除*/{printf("\nError.\'%s\'.\n",fname);wgetchar=1;}else{fpaddrno1=ufd[k]->ufdfile[i].fpaddr;xt");remove(str);n",fname);wgetchar=1;}}}else'%s\'dosenotexist.\n",fname);wgetchar=1;}}}2Open函数voidOpenF()/*OpenFile*/{charfname[MAXNAME];inti,k,j;if(strcmp(strupr(dirname),strupr(username))!=0)/*在自己的目录里才能打开*/{printf("\.\n");wgetchar=1;}else{k=ExistD(username);for(j=0;j<fcount[k];j++){printf("%15s",ufd[k]->ufdfile[j].fname);}printf("\nPleaseinputFileName:");gets(fname);fopen==1)'%s\'isinopenstatus.\n",fname);wgetchar=1;}else{ifopen[k][i].ifopen=1;mode==0)/*根据文件的模式设置打开模式*/{ifopen[k][i].openmode=0;}elseif(ufd[k]->ufdfile[i].fmode==1){ifopen[k][i].openmode=1;}elseif(ufd[k]->ufdfile[i].fmode==2){ifopen[k][i].openmode=2;}elseifopen[k][i].openmode=3;printf("\n\'%s\'isopenedsuccessfully\n",fname);wgetchar=1;}}else'%s\'dosenotexist.\n",fname);wgetchar=1;}}}3Close函数voidCloseF()/*CloseFile*/{charfname[MAXNAME];inti,k,j;if(strcmp(strupr(dirname),strupr(username))!=0)/*不在自己的目录里没法进行*/{printf("\.\n");wgetchar=1;}else{k=ExistD(username);for(j=0;j<fcount[k];j++)/*列出已经打开的文件*/ {if(ifopen[k][j].ifopen==1)name);}printf("\nPleaseinputFileName:");gets(fname);fopen=0;/*关闭文件*/printf("\n\'%s\'closedsuccessfully\n",fname);wgetchar=1;}else'%s\'dosenotexist.\n",fname);wgetchar=1;}}}4Write函数voidWriteF()/*WriteFile*/{inti,k,n=0;intlength;charfname[MAXNAME],values[1000];charstr[255],str1[255],c;if(strcmp(strupr(ltrim(rtrim(dirname))),"")==0)n");wgetchar=1;return;}printf("\nCaution:Openfilefirst\n");printf("OpenedFile(s)List:\n");k=ExistD(dirname);fopen==1)name);n++;}if((n%4==0)&&(n!=0))printf("\n");}printf("\n%dfilesopenned.\n",n);if(n==0)wgetchar=1;fopen==1)penmode==1)||(ifopen[k][i].o penmode==2))paddr,str,10);xt");fp_file=fopen(str,"ab");length=ufd[k]->ufdfile[i].flengt h+length;n",ufd[k]->ufdfile[i].flength);printf("\n\nYouhavewritefilesuccessfully!!");fclose(fp_file);wgetchar=0;}elseif(ifopen[k][i].openmode==0)'%s\'\'twrite.\n",fname) ;wgetchar=1;}else'%s\'\'twrite.\n",fname);wgetchar=1;}}else'%s\'\n",fname);wgetchar=1;}}else'%s\'doesnotexist.\n",fname);wgetchar=1;}}}【程序流程设计】1总的功能结构图：2部分子模块程序流程图（1）打开命令的程序流程图：（2）关闭命令的程序流程图：（3）写命令的程序流程图：（4）删除命令的程序流程图：【测试结果】1删除文件2打开的文件不能删除3打开文件，其中已经打开的文件不能再次打开3关闭文件4写文件，其中只有打开了文件才能写入5写文件6只读文件和保护文件不能写入7其他函数【参考文献】计算机操作系统,西安电子科技大学出版社，方敏主编, 【源程序清单】#include""#include""#include""#include""#define MAXNAME25/*thelargestlengthofmfdname,ufdname,filename*/#define MAXCHILD50/*thelargestchild每个用户名下最多有50个文件*/#define MAX(MAXCHILD*MAXCHILD)/*thesizeoffpaddrno*/typedefstruct/*thestructureofOSFILE定义主文件*/{int fpaddr;/*filephysicaladdress*/int flength;/*filelength*/int fmode;/*filemode:0-ReadOnly;1-WriteOnly;2-ReadandWrite;3-Protect;*/ char fname[MAXNAME];/*filename*/}OSFILE;typedefstruct/*thestructureofOSUFD定义用户文件目录*/{char ufdname[MAXNAME];/*ufdname*/OSFILEufdfile[MAXCHILD];/*ufdownfile*/}OSUFD;typedefstruct/*thestructureofOSUFD'LOGIN定义登陆*/char ufdname[MAXNAME];/*ufdname*/char ufdpword[8];/*ufdpassword*/}OSUFD_LOGIN;typedefstruct/*fileopenmode定义操作方式*/{int ifopen;/*ifopen:0-close,1-open*/int openmode;/*0-readonly,1-writeonly,2-readandwrite,3-protect*/}OSUFD_OPENMODE;void LoginF();/*LOGINFileSystem*/void DirF();/*DirFileSystem*/void CreateF();/*CreateFile*/void DeleteF();/*DeleteFile*/void ModifyFM();/*ModifyFileMode*/void OpenF();/*OpenFile*/void CloseF();/*CloseFile*/void ReadF();/*ReadFile*/void WriteF();/*WriteFile*/void QuitF();/*QuitFileSystem*/void CdF();/*ChangeDir*/void help();char*rtrim(char*str);/*removethetrailingblanks.*/char*ltrim(char*str);/*removetheheadingblanks.*/void InputPW(char*password);/*inputpassword,use'*'replace*/int ExistD(char*dirname);/*WhetherDirNameExist,Exist-i,NotExist-0*/int WriteF1();/*writefile*/int ExistF(char*filename);/*WhetherFileNameExist,Exist-i,NotExist-0*/void SetPANo(int RorW);/*Setphysicaladdressnum*/int FindPANo();/*findoutphysicaladdressnum*/int ucount=0;/*thecountofmfd'sufds用户数*/int fcount[MAXCHILD];/*thecountofufd'sfiles子文件数*/int loginsuc=0;/*whetherloginsuccessfully登陆成功*/char username[MAXNAME];/*recordloginuser'sname22用户名*/char dirname[MAXNAME];/*recordcurrentdirectory使用的用户目录*/int fpaddrno[MAX];/*recordfilephysicaladdressnum物理地址号，存放自己所创建的所有文件的地址*/int wgetchar;/*whethergetchar()*/OSUFD*ufd[MAXCHILD];/*ufdandufdownfiles*/OSUFD_LOGINufd_lp;;QuitF();exit(0);break;case10:clrscr();choiceend=1;break;case11:CdF();choiceend=1;break;;}char*rtrim(char*str)/*removethetrailingblanks.去掉登陆用户名的尾空格*/int n=strlen(str)-1;while(n>=0){if(*(str+n)!=''){*(str+n+1)='\0';break;}else n--;}if(n<0)str[0]='\0';return str;}char*ltrim(char*str)/*removetheheadingblanks.去掉登陆用户名的头空格*/ {strrev(str);name),strupr(filename))==0){exist=1;break;}if(exist)return(i);elsereturn(-1);}int FindPANo()/*findoutphysicaladdressnum*/{int i;for(i=0;i<MAX;i++)if(fpaddrno[i]==0){fpaddrno[i]=1;break;}if(i<MAX)return(i);elsereturn(-1);}int WriteF1()/*writefile*/{int length=0;char c;printf("Pleaseinputtext(\'#\'standsforend):\n");while((c=getchar())!='#'){fprintf(fp_file,"%c",c);if(c!='\n')length++;}fprintf(fp_file,"\n");fclose(fp_file);return(length);}void LoginF()/*LOGINFileSystem登陆函数*/{char loginame[MAXNAME],loginpw[9],logincpw[9],str[50];xt");ufd[j]=(OSUFD*)malloc(sizeof(OSUFD));fopen=0;ifopen[j][i].openmode=4;}fclose(fp_ufd);}fclose(fp_mfd);ucount=j;SetPANo(0);printf("\n\nLoginsuccessful!WelcometothisFileSystem\n\n");loginsuc=1;return;}else xt");if((fp_ufd=fopen(str,"rb"))==NULL){fp_ufd=fopen(str,"wb");fclose(fp_ufd);}fp_mfd=fopen("d:\\osfile\\","rb");for(j=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;j++){strcpy(str,"d:\\osfile\\");strcat(str,;strcat(str,".txt");ufd[j]=(OSUFD*)malloc(sizeof(OSUFD));strcpy(ufd[j]->ufdname,strupr);fp_ufd=fopen(str,"rb");for(i=0;fread(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd)!=0;i++,fcount[j]++)fopen =0;ifopen[j][i].openmode=4;}fclose(fp_ufd);}fclose(fp_mfd);ucount=j;SetPANo(0);printf("\n\nLoginSuccessful!WelcometothisSystem\n\n");loginsuc=1;return;}else");getch();clrscr();printf("\n%14s%16s%14s%10s%18s\n","FileName","FileAddress","FileLength","Type","Fil eMode");}itoa(ufd[j]->ufdfile[i].fpaddr,str,10);mode==0)strcpy(sfmode,"ReadOnly");elseif(ufd[j]->ufdfile[i].fmode==1)strcpy(sfmode,"WriteOnly");elseif(ufd[j]->ufdfile[i].fmode==2)strcpy(sfmode,"ReadAndWrite");else strcpy(sfmode,"Protect");printf("%14s%16s%14d%10s%18s\n",ufd[j]->ufdfile[i].fname,sfpaddr,ufd[j]->ufdfile[i] .flength,"<FILE>",sfmode);}printf("\n%3dfile(s)\n",fcount[j]);}else.");getch();clrscr();printf("\n%14s%18s%8s\n","DirName","OwnFileCount","Type");}printf("%14s%18d%8s\n",ufd[i]->ufdname,fcount[i],"<UFD>");count=count+fcount[i];}printf("\n%3ddir(s),%5dfile(s)\n",ucount,count);}}void CreateF()/*CreateFile*/{int fpaddrno,flag=1,i;char fname[MAXNAME],str[50],str1[50],a[25];char fmode[25];if(strcmp(strupr(dirname),strupr(username))!=0)n");wgetchar=1;}else{printf("\nPleaseinputFileName:");gets(fname);ltrim(rtrim(fname));if(ExistF(fname)>=0){printf("\\'%s\'hasalreadyexisted.\n",fname);wgetchar=1;}else{printf("PleaseinputFileMode(0-ReadOnly,1-WriteOnly,2-ReadandWrite,3-Protect):");gets(fmode);ltrim(rtrim(fmode));if((strcmp(fmode,"0")==0)||(strcmp(fmode,"1")==0)||(strcmp(fmode,"2")==0)||(strcmp( fmode,"3")==0)){fpaddrno=FindPANo();if(fpaddrno>=0)name,fname);paddr=fpaddrno;ufd[i]->ufdfile[fcount[i]].fmode=atoi(fmode);ifopen[i][fcount[i]].ifopen=0;ifopen[i][fcount[i]].openmode=4;strcpy(str,"d:\\osfile\\file\\file");itoa(fpaddrno,str1,10);strcat(str,str1);strcat(str,".txt");fp_file=fopen(str,"wb");fclose(fp_file);fcount[i]++;while(flag){printf("Inputtextnow(Y/N):");gets(a);ltrim(rtrim(a));ufd[i]->ufdfile[fcount[i]-1].flength=0;if(strcmp(strupr(a),"Y")==0){fp_file=fopen(str,"wb+");length=WriteF1();flag=0;}elseif(strcmp(strupr(a),"N")==0){flag=0;wgetchar=1;}}printf("\n\'%s\'hasbeencreatedsuccessfully!\n",fname);}else{printf("\nFail!.\n");wgetchar=1;}}else{printf("\\'sRangeis0-3\n");wgetchar=1;}}}}void DeleteF()/*DeleteFile*/{char fname[MAXNAME],str[50],str1[50];int i,k,j;int fpaddrno1;if(strcmp(strupr(ltrim(rtrim(dirname))),"")==0)/*无法删除主目录的文件*/{printf("\.\n");wgetchar=1;}if(strcmp(strupr(dirname),strupr(username))!=0)/*无法删除非自己目录的文件*/ {printf("\.\n");wgetchar=1;}else{printf("\nPleaseinputFileName:");gets(fname);fopen==1)/*文件打开时无法删除*/{printf("\nError.\'%s\'.\n",fname);wgetchar=1;}else{if(ufd[k]->ufdfile[i].fmode==3)/*被保护的文件无法删除*/{printf("\nError.\'%s\'.\n",fname);wgetchar=1;}else{fpaddrno1=ufd[k]->ufdfile[i].fpaddr;xt");remove(str);n",fname);wgetchar=1;}}}else'%s\'dosenotexist.\n",fname);wgetchar=1;}}}void ModifyFM()/*ModifyFileMode*/{char fname[MAXNAME],str[50];int i,k;char fmode[25];/*whetherdelete*/if(strcmp(strupr(dirname),strupr(username))!=0){printf("\.\n");wgetchar=1;}else{printf("\nPleaseinputFileName:");gets(fname);ltrim(rtrim(fname));i=ExistF(fname);if(i>=0){k=ExistD(username);if(ifopen[k][i].ifopen==1){printf("\nError.\'%s\'.\n",fname);wgetchar=1;}else{if(ufd[k]->ufdfile[i].fmode==0)strcpy(str,"readonly");/*FileMode*/elseif(ufd[k]->ufdfile[i].fmode==1)strcpy(str,"writeonly");elseif(ufd[k]->ufdfile[i].fmode==2)strcpy(str,"readandwrite");else strcpy(str,"Protect");printf("\'%s\'filemodeis%s.\n",fname,strupr(str));printf("Modifyto(0-readonly,1-writeonly,2-readandwrite,3-Protect):");gets(fmode);ltrim(rtrim(fmode));if(strcmp(fmode,"0")==0){ufd[k]->ufdfile[i].fmode=0;printf("\n\'%s\'hasbeenmodifiedtoREADONLYmodesuccessfully.\n",fname);wgetchar=1;}elseif(strcmp(fmode,"1")==0){ufd[k]->ufdfile[i].fmode=1;printf("\n\'%s\'hasbeenmodifiedtoWRITEONLYmodesuccessfully.\n",fname);wgetchar=1;}elseif(strcmp(fmode,"2")==0){ufd[k]->ufdfile[i].fmode=2;printf("\n\'%s\'hasbeenmodifiedtoREADANDWRITEmodesuccessfully.\n",fname);wgetchar=1;}elseif(strcmp(fmode,"3")==0){ufd[k]->ufdfile[i].fmode=3;printf("\n\'%s\'hasbeenmodifiedtoFORBIDmodesuccessfully.\n",fname);wgetchar=1;}else{printf("\nError.\'%s\'isnotmodified.\n",fname);wgetchar=1;}}}else{printf("\nError.\'%s\'dosenotexist.\n",fname);wgetchar=1;}}}void OpenF()/*OpenFile*/{char fname[MAXNAME];int i,k,j;if(strcmp(strupr(dirname),strupr(username))!=0)/*在自己的目录里才能打开*/ {printf("\.\n");wgetchar=1;}else{k=ExistD(username);for(j=0;j<fcount[k];j++){printf("%15s",ufd[k]->ufdfile[j].fname);}printf("\nPleaseinputFileName:");gets(fname);fopen==1)'%s\'isinopenstatus.\n",fname);wgetchar=1;}else{ifopen[k][i].ifopen=1;mode==0)/*根据文件的模式设置打开模式*/{ifopen[k][i].openmode=0;}elseif(ufd[k]->ufdfile[i].fmode==1){ifopen[k][i].openmode=1;}elseif(ufd[k]->ufdfile[i].fmode==2){ifopen[k][i].openmode=2;}else ifopen[k][i].openmode=3;printf("\n\'%s\'isopenedsuccessfully\n",fname);wgetchar=1;}}else'%s\'dosenotexist.\n",fname);wgetchar=1;}}}void CloseF()/*CloseFile*/{char fname[MAXNAME];int i,k,j;if(strcmp(strupr(dirname),strupr(username))!=0)/*不在自己的目录里没法进行*/ {printf("\.\n");wgetchar=1;}else{k=ExistD(username);for(j=0;j<fcount[k];j++)/*列出已经打开的文件*/{if(ifopen[k][j].ifopen==1)name);}printf("\nPleaseinputFileName:");gets(fname);fopen=0;'%s\'dosenotexist.\n",fname);wgetchar=1;}}}void ReadF()/*ReadFile*/{int i,k,n=0;char fname[MAXNAME];char str[255],str1[255],c;if(strcmp(strupr(ltrim(rtrim(dirname))),"")==0)n");wgetchar=1;return;}printf("\nCaution:Openfilefirst\n");printf("OpenedFile(s)List:\n");k=ExistD(dirname);for(i=0;i<fcount[k];i++){if(ifopen[k][i].ifopen==1)name);n++;}if((n%4==0)&&(n!=0))printf("\n");}printf("\n%dfilesopenned.\n",n);if(n==0)wgetchar=1;fopen==1){if((ifopen[k][i].openmode==0)||(ifopen[k][i].openmode==2))paddr,str,10);strcpy(str1,"file");strcat(str1,str);strcpy(str,"d:\\osfile\\file\\");strcat(str,str1);strcat(str,".txt");fp_file=fopen(str,"rb");fseek(fp_file,0,0);printf("\nThetextis:\n\n");printf("");while(fscanf(fp_file,"%c",&c)!=EOF)if(c=='\n')printf("\n");else printf("%c",c);printf("\n\n%dLength.\n",ufd[k]->ufdfile[i].flength);fclose(fp_file);wgetchar=1;}elseif(ifopen[k][i].openmode==1)'%s\'\'tread.\n",fname);wgetchar=1;}else'%s\'\'tread.\n",fname);wgetchar=1;}}else{printf("\nError.\'%s\'\n",fname);wgetchar=1;}}else{printf("\nError.\'%s\'doesnotexist.\n",fname);wgetchar=1;}}}void WriteF()/*WriteFile*/{int i,k,n=0;int length;char fname[MAXNAME],values[1000];char str[255],str1[255],c;if(strcmp(strupr(ltrim(rtrim(dirname))),"")==0)n");wgetchar=1;return;}printf("\nCaution:Openfilefirst\n");printf("OpenedFile(s)List:\n");k=ExistD(dirname);fopen==1)name);n++;}if((n%4==0)&&(n!=0))printf("\n");}printf("\n%dfilesopenned.\n",n);if(n==0)wgetchar=1;fopen==1)penmode==1)||(ifopen[k][i].openmode==2))paddr,str,10);x t");fp_file=fopen(str,"ab");length=ufd[k]->ufdfile[i].flength+length;n",ufd[k]->ufdfile [i].flength);printf("\n\nYouhavewritefilesuccessfully!!");fclose(fp_file);wgetchar=0;}elseif(ifopen[k][i].openmode==0)'%s\'\'twrite.\n",fname);wgetchar=1;}else'%s\'\'twrite.\n",fname);wgetchar=1;}}else'%s\'\n",fname);wgetchar=1;}}else'%s\'doesnotexist.\n",fname);wgetchar=1;}}}void QuitF()/*QuitFileSystem*/{int i,j;char str[50];SetPANo(1);if(fp_mfd!=NULL)fclose(fp_mfd);xt");fp_ufd=fopen(str,"wb");fclose(fp_ufd);fp_ufd=fopen(str,"ab");for(i=0;i<fcount[j];i++)fwrite(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd);fclose(fp_ufd);}}void CdF()/*ExchangeDir更换用户*/{char dname[MAXNAME];printf("\nPleaseinputDirName:");gets(dname);ltrim(rtrim(dname));if(ExistD(dname)>=0)strcpy(dirname,strupr(dname));elseif(strcmp(strupr(dname),"CD..")==0)strcpy(ltrim(rtrim(dirname)),"");else printf("\nError.\'%s\'doesnotexist.\n",dname);}void help(void){printf("\nTheCommandList\n");printf("\nCdAttribCreatewriteReadOpenClsDeleteExitClose\n");}【设计总结】UNIX系统中的文件系统是人们最感兴趣的，也是最成功的一部分。
操作系统-文件系统课程设计报告
《操作系统》课程设计题目名称多用户多级目录共享文件系统的实现_学生学院计算机学院专业班级 10级计算机科学与技术7班学号学生姓名指导教师刘老师20年月日一、可行性分析随着信息化进程，文件管理越来越受到重视，并且逐渐成为国内外业界研究的热点。
在现有的操作系统中，几乎都是通过文件系统来组织和管理计算机中所存储的程序和数据等大量的文件。
在现代OS中，几乎毫毛例外地是通过文件系统来组织和管理在计算机中存储和大量程序和数据的；或者说，文件系统的管理功能，是通过把它所管理的程序和数据组织成一系列文件的方法来实现的。
而文件则是指具有文件名的若干相关元素的集合。
元素通常是记录，而记录又是一组有意义的数据项的集合。
通过分析，可知文件系统对大多数文件的操作，器过程大致都是这样两步：第一步是通过检索文件目录来找到指定文件的属性及其在外存上的位置；第二步是对文件实施相应的操作，如读文件或写文件。
为了便于管理和控制文件，根据系统管理员或用户所规定的存取控制属性，将文件分为只读文件、读写文件和只执行文件三类。
而文件系统的模型主要分为三个层次，分别是对象及其属性、对对象的操纵和管理的软件集合、文件系统接口，其最底层的是对象及其属性；中间层对对象进行操纵和管理的软件集合；最高层是文件系统提供给用户的接口。
用户通过文件系统所提供的系统调用实施对文件的操作，如创建文件、删除无文件、读文件、写文件等，为了方便用户使用文件而提供了更多对文件的操作，如打开和关闭文件。
软硬件可行性分析：本模拟系统的实现需要一台PC机作为硬件设备，此外，软件开发环境包括：Win7、VC++6.0,.因此，该模拟系统具备实现条件，综合分析，系统在成本、技术、操作上，都是可行的。
技术可行性分析：在当前的技术条件下，该系统的各个功能模块在理论上而言都是能实现的；根据自己掌握的技术情况，在规定的期限内，系统的开发设计能完成。
二、需求分析1、功能需求分析功能划分：本模拟系统主要针对文件的管理和操作名主要有：创建用户、文件、文件夹，读文件，写文件，执行文件，关闭文件，删除用户、文件夹、文件的功能。
操作系统课程设计报告文件系统
盘索引结点号一并组成一个新目录项，记入其父目录文件中。
文件被撤消时，系统要回收该文件的磁盘索引结点，从其父目录中删除该目录项。
随着文件的打开与关闭，系统还要为之分派和回收内存索引结点。
②磁盘索引结点中，包括有关文件的下述一系列信息：文件模式di_mode、文件所有者用户标识符di_uid、同组用户标识符di_gid、文件长度di_size、文件的联接计数di_nlink、文件的物理地址di_addr、文件的访问时刻di_atime、文件的修改时刻di_mtime和文件的成立时刻di_citime。
③内存索引结点：文件被打开后，系统为它在内存索引结点表区中建一内存索引结点，以方便用户和系统对文件的访问。
④磁盘索引结点的分派与回收分派进程ialloc：当内核创建一新文件时，要为之分派一空闲磁盘i结点。
如分派成功，便再分派一内存i结点。
其进程如下：检查超级块上锁否。
由于超级块是临界资源，诸进程必需互斥地访问它，故在进入ialloc后，要先检查它是不是已上锁，若是则睡眠等待；检查i结点栈空否。
若i结点栈中已无空闲结点编号，则应从盘中再调入一批i 结点号进栈。
若盘中已无空闲i结点，则犯错处置，返回；从空闲i结点编号栈中分派一i结点，并对它初始化、填写有关文件的属性；分派内存i结点；将磁盘i结点总数-1，置超级块修改标志，返回。
回收进程ifree：当删除文件时，应回收其所占用的盘块及相应的磁盘i结点。
具体有：检查超级块上锁否。
若是，直接返回，即不把本次回收的i结点号记入空闲i结点编号栈中；检查i结点编号栈满否。
若已满，无法再装入新回收的i结点号，当即返回，若未满，便将回收的i结点编号进栈，并使当前空闲结点数+1；置超级块修改标志，返回。
⑤内存索引结点的分派与回收分派进程iget：虽然iget用在打开文件时为之分派i结点，但由于允许文件被共享，因此，若是一文件已被其他用户打开并有了内存i结点，则现在只需将i结点中的引用计数+1。
操作系统课程设计文件系统
操作系统课程设计：文件系统一、引言文件系统是操作系统中的一个重要组成部分，负责管理计算机存储设备上的文件和目录。
一个高效可靠的文件系统对于操作系统和用户来说都至关重要。
在操作系统课程中，设计一个文件系统是一项重要的任务，可以帮助学生深入了解文件系统的原理和实现细节。
本文档将介绍一个简单的文件系统设计，旨在帮助初学者理解文件系统的基本概念和工作原理。
我们将首先介绍文件系统的基本概念，然后讨论文件系统的设计思路和关键组成部分。
最后，我们将讨论如何实现和测试文件系统。
二、文件系统的基本概念文件系统是操作系统提供的一种存储管理机制，用于将文件组织成有层次的结构并提供对文件的访问和管理。
在一个文件系统中，文件被组织成目录（或文件夹）的层次结构，用户可以使用文件路径来访问文件和目录。
文件系统通常提供以下功能： - 文件和目录的创建、删除和重命名 - 文件和目录的读取和写入 - 文件和目录的权限管理 - 文件的共享和保护 - 文件的存储管理三、设计思路在设计文件系统时，需要考虑以下几个关键方面：1. 文件系统的组织结构文件系统可以采用不同的组织结构，常见的包括层次结构、网络结构和日志结构。
在设计文件系统时，需要根据具体需求选择合适的结构。
2. 文件和目录的管理文件系统需要提供对文件和目录的管理功能，包括创建、删除、重命名和移动等操作。
此外，还需要支持文件和目录的权限管理，确保只有授权用户可以进行相应操作。
3. 文件的存储管理文件系统需要负责将文件存储在磁盘或其他存储设备上，并提供高效的读写操作。
存储管理的关键是如何将文件划分为适当大小的块并将它们存储在存储设备上。
4. 文件的共享和保护文件系统需要支持文件的共享和保护。
共享可以使多个用户同时访问同一文件，保护则确保只有合法用户可以进行读写操作。
四、文件系统的关键组成部分一个典型的文件系统通常由以下几个关键组成部分构成：1. 文件控制块（FCB）文件控制块是文件系统中一个重要的数据结构，用于记录文件的相关信息，包括文件名、大小、权限和存储位置等。
操作系统文件管理系统 课程设计
操作系统文件管理系统课程设计
操作系统文件管理系统课程设计一般包括以下内容：
1. 基本概念和原理：介绍文件管理系统的基本概念和原理，包括文件、目录、文件系统、文件操作等。
2. 设计需求分析：明确设计需求，包括基本功能、用户需求、性能要求等。
3. 文件存储结构的设计：设计文件存储结构，包括文件分配方式、文件存储结构、文件目录结构、文件保护等。
4. 文件操作的实现：实现文件的创建、打开、读写、删除等基本操作，以及文件的复制、移动、重命名等高级操作。
5. 目录管理的实现：实现目录的创建、删除、重命名等操作，以及目录的遍历和搜索等功能。
6. 文件系统的实现：实现文件系统的格式化、挂载、卸载等操作，以及文件系统的安全性和可靠性保障。
7. 用户界面的设计：设计用户界面，包括命令行界面和图形界面，以方便用户进行文件管理操作。
8. 系统测试和调试：对系统进行测试和调试，包括单元测试、集成测试、性能测试等，以确保系统的稳定性和可靠性。
9. 报告撰写和展示：根据课程设计的要求，编写设计报告和展示文稿，介绍系统的设计思路、实现方法和成果。
以上是一个基本的操作系统文件管理系统课程设计的内容，具体可以根据教师的要求和课程的安排进行适当调整和扩展。
操作系统-文件系统课程设计报告(附源码)
操作系统课程设计题目文件系统学院计算机学院专业计算机科学与技术年级班别 10级7 班学号 3110006154 学生姓名指导教师刘老师20年月日文件系统一、课程设计的内容：模拟文件系统实现的基本功能，了解文件系统的基本结构和管理方法，加深理解文件系统的内部功能及内部实现。
通过用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程，从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
二、可行性分析：可行性分析是通过对项目的主要内容和配套条件，并通过对各方面进行调查研究和分析比较，并对项目建成以后所带来的影响，从而提出该项目是否值得投资和如何进行建设的咨询意见，是一种综合性的系统分析方法。
可行性分析应具有预见性、公正性、可靠性、科学性的特点。
这里以三个方面来分析此次设计：经济可行性、技术可行性、法律可行性。
1、经济可行性：编写该文件系统，只需要用到PC机和VC++6.0编程软件，不需要花费金钱，所以，在经济方面，这个课程设计适合做。
2、技术可行性：在做这个课程设计，事先需要掌握的知识有C/C++语言，数据结构，操作系统，PC机的基本操作和VC++6.0软件的使用方法等。
目前，这些知识都已经学习并掌握了，所以在技术方面，这个课程设计也适合做。
3、法律可行性：做这个课程设计，只是为了掌握文件系统的基本内容，提升自己的编程能力，没有违反法律法规，所以，在法律方面，这个课程设计也适合做。
三、需求分析1．设计一个多用户多级目录文件管理系统。
2．要设计多个实用命令并设置文件保护措施。
3．设计一个较实用的用户界面，方便用户使用，界面要为用户提供足够的选择信息，不需用户打入冗长的命令4. 功能简介：①多用户管理，多级目录形式。
②基本的文件操作功能，如新建文件、打开文件、写入文件、关闭文件、读取文件等。
③用户间文件的共享功能四、概要设计(逻辑图)1.系统结构图:2、界面简单说明该系统主要分为两个界面，用户操作界面及文件操作管理界面。
课程设计文件操作系统
课程设计文件操作系统一、教学目标本课程的教学目标是使学生掌握操作系统的基本原理和常用操作系统的使用方法。
具体包括：1.了解操作系统的定义、功能和分类。
2.掌握操作系统的基本原理，如进程管理、内存管理、文件管理和设备管理。
3.熟悉常用操作系统的特点和使用方法，如Windows、Linux和macOS。
4.能够熟练使用操作系统进行日常计算机操作。
5.能够掌握操作系统的基本配置和优化方法。
6.能够运用操作系统的基本原理解决实际问题。
情感态度价值观目标：1.培养学生对操作系统的兴趣和好奇心，提高学生主动学习的积极性。
2.培养学生团队合作精神，学会与他人分享和交流操作系统的知识和经验。
3.培养学生对操作系统的安全意识，提高学生保护个人隐私和数据的能力。
二、教学内容本课程的教学内容主要包括操作系统的基本原理和常用操作系统的使用方法。
具体安排如下：1.操作系统概述：介绍操作系统的定义、功能和分类。
2.进程管理：讲解进程的概念、进程的状态、进程控制块、进程调度算法等。
3.内存管理：介绍内存的概念、内存分配与回收策略、虚拟内存等。
4.文件管理：讲解文件和目录的概念、文件系统的结构、文件访问控制等。
5.设备管理：介绍设备的概念、设备驱动程序、输入输出控制等。
6.Windows操作系统：讲解Windows操作系统的特点、界面布局、基本操作和高级功能。
7.Linux操作系统：介绍Linux操作系统的特点、界面布局、基本操作和高级功能。
8.macOS操作系统：讲解macOS操作系统的特点、界面布局、基本操作和高级功能。
三、教学方法为了提高学生的学习兴趣和主动性，本课程将采用多种教学方法，如讲授法、讨论法、案例分析法和实验法等。
1.讲授法：通过讲解操作系统的原理和概念，使学生掌握基本知识。
2.讨论法：学生分组讨论操作系统的实际应用场景和问题解决方案，培养学生的团队合作精神。
3.案例分析法：分析实际案例，使学生更好地理解操作系统的基本原理和常用操作系统的特点。
操作系统课程设计为LINUX设计一个简单的二级文件系统
操作系统课程设计为LINUX设计一个简单的二级文件系统一．项目概述本课程设计旨在通过设计一个简单的多用户文件系统，加深学生对文件系统内部功能及内部实现的理解，并提高学生的程序设计能力、算法设计质量与程序设计素质。
二．设计题目为LINUX设计一个简单的二级文件系统，要求实现以下命令：Login用户登录、Dir列文件目录、Create创建文件、Delete删除文件、Open打开文件、Close关闭文件、Read读文件、Write写文件。
列目录时需包括文件名、物理地址、保护码和文件长度。
源文件需进行读写保护。
三．开发语言及实现平台或实验环境本课程设计的开发语言为C语言，实现平台为Linux操作系统。
学生需要在规定时间内完成程序的编写和调试，并书写课程设计报告。
四．时间安排1月17日布置课程设计任务，学生需要自行查阅资料并准备程序。
1月18日至1月20日，学生需要在机房上机调试程序，并书写课程设计报告。
1月21日上午，学生需要提交课程设计报告及相关文档。
每位学生应独立完成各自的任务，每天至少在设计室工作半天。
五．具体要求1.课程设计报告应按统一通用格式书写，具体格式要求请在网络上查阅。
2.指导教师和教研室主任（或责任教师）需要在规定时间内签署相应的文件。
设计目的：本设计旨在开发一款能够实现某种功能的程序，为用户提供便利。
设计内容：5.1.该程序将包括两个主要功能：A和B。
A功能将执行某种操作，而B功能将提供用户界面，使其能够轻松地使用A功能。
5.2.此外，该程序还将包括其他辅助功能，例如C和D。
这些功能将提高程序的可用性和实用性。
任务：该程序的主要任务是为用户提供一种方便、高效的解决方案，使其能够更轻松地实现某种目标。
主程序流程图：程序的主要流程将包括以下步骤：用户打开程序，选择所需的功能，程序执行相应的操作，最终将结果返回给用户。
程序设计：6.1.在程序设计方面，我们将采用一种灵活、可扩展的架构，以便能够轻松地添加新的功能和模块。
操作系统课程设计(完整规范版)
操作系统课程设计(完整规范版)一、引言操作系统是计算机系统的核心软件，它管理计算机的硬件资源，为应用程序提供运行环境。
本课程设计旨在通过实践，加深学生对操作系统原理的理解，提高学生的编程能力和系统设计能力。
二、课程目标1. 理解操作系统的基本原理和功能。
2. 掌握进程管理、内存管理、文件系统等核心模块的设计和实现。
3. 熟悉操作系统调度的基本算法。
4. 提高学生的编程能力和系统设计能力。
三、课程内容1. 操作系统概述操作系统的定义、功能和发展历程操作系统的基本组成和结构操作系统的类型和特点2. 进程管理进程的定义、状态和转换进程控制块（PCB）的结构和作用进程同步与互斥进程通信进程调度算法3. 内存管理内存管理的目标连续内存管理技术非连续内存管理技术页面置换算法4. 文件系统文件系统的定义和功能文件的结构和类型文件存储空间管理文件目录管理文件操作5. I/O系统I/O系统的功能和组成 I/O设备管理I/O调度算法缓冲管理6. 系统调用系统调用的定义和类型系统调用的实现机制常用系统调用分析7. 实验与课程设计实验目的和要求实验内容和步骤课程设计题目和要求课程设计报告格式四、课程考核1. 平时成绩（30%）：包括课堂表现、实验报告和作业完成情况。
2. 实验成绩（30%）：包括实验操作和实验报告。
3. 课程设计成绩（40%）：包括设计报告、代码实现和答辩表现。
1. 《操作系统概念》作者：亚伯拉罕·西尔伯斯查茨等2. 《现代操作系统》作者：安德鲁·S·塔嫩鲍姆3. 《操作系统导论》作者：威廉·斯托林斯六、附录1. 课程设计报告模板2. 实验报告模板3. 课程设计答辩评分标准七、课程安排1. 理论学习操作系统概述（2课时）进程管理（4课时）内存管理（4课时）文件系统（4课时）I/O系统（2课时）系统调用（2课时）2. 实验与课程设计进程管理实验（2课时）内存管理实验（2课时）文件系统实验（2课时）I/O系统实验（2课时）课程设计（8课时）课程考核（2课时）八、实验与课程设计指导1. 实验指导进程管理实验：通过模拟进程的创建、撤销、阻塞和唤醒等操作，理解进程管理的原理。
操作系统课程设计---简单文件系统的实现
操作【2 】体系课程设计报告小组编号: 小构成员:一.课程设计概述:1.标题: 简略文件体系的实现2.实现内容(1)在内存中开拓一个虚拟磁盘空间作为文件存储分区,在其上实现一个简略的基于多级目次的单用户单义务体系中的文件体系.在退出该文件体系的应用时,应将该虚拟文件体系以一个Windows 文件的方法保存到磁盘上,以便下次可以再将它恢复到内存的虚拟磁盘空间中.(2)文件存储空间的分派可采用显式链接分派或其他的方法.(3)余暇磁盘空间的治理可选择位示图或其他的方法.假如采用位示图来治理文件存储空间,并采用显式链接分派方法,那么可以将位示图归并到FAT中.(4)文件目次构造采用多级目次构造.为了简略起见,可以不应用索引结点,个中的每个目次项应包含文件名.物理地址.长度等信息,还可以经由过程目次项实现对文件的读和写的破坏.●请求供给以下操作敕令:●my_format: 对文件存储器进行格局化,即按照文件体系的构造对虚拟磁盘空间进行布局,并在其上创建根目次以及用于治理文件存储空间等的数据构造.●my_mkdir: 用于创建子目次.●my_rmdir: 用于删除子目次.●my_ls: 用于显示目次中的内容.●my_cd: 用于更改当前目次.●my_create: 用于创建文件.●my_open: 用于打开文件.●my_close: 用于封闭文件.●my_write: 用于写文件.●my_read: 用于读文件.●my_rm: 用于删除文件.二、my_exitsys: 用于退出文件体系.设计思绪（重要算法描写.程序流程图等）:1. 体系主函数main()（1）对应敕令: 无（2）敕令挪用格局: 无（3）函数设计格局: void main()（4）功效: 体系主函数（5）输入: 无（6）输出: 无（7）函数需完成的工作:①对前面界说的全局变量进行初始化;②挪用startsys()进入文件体系;③列出文件体系供给的各项功效及敕令挪用格局;④显示敕令行提醒符,等待用户输入敕令;⑤将用户输入的敕令保存到一个buf中;⑥对buf中的内容进行敕令解析,并挪用响应的函数履行用户键入的敕令;⑦假如敕令不是“my_exitsys”,则敕令履行完毕后转④.2.进入文件体系函数startsys()（1）对应敕令: 无（2）敕令挪用格局: 无（3）函数设计格局: void startsys()（4）功效: 由main()函数挪用,进入并初始化我们所树立的文件体系,以供用户应用.（5）输入: 无（6）输出: 无.（7）函数需完成的工作:①申请虚拟磁盘空间;②应用c说话的库函数fopen()打开myfsys文件: 若文件消失,则转③;若文件不消失,则创建之,转⑤③应用c说话的库函数fread()读入myfsys文件内容到用户空间中的一个缓冲区中,并断定其开端的8个字节内容是否为“10101010”（文件体系魔数）,假如是,则转④;不然转⑤;④将上述缓冲区中的内容复制到内存中的虚拟磁盘空间中;转⑦⑤在屏幕上显示“myfsys文件体系不消失,如今开端创建文件体系”信息,并挪用my_format()对①中申请到的虚拟磁盘空间进行格局化操作.转⑥;⑥将虚拟磁盘中的内容保存到myfsys文件中;转⑦⑦应用c说话的库函数fclose()封闭myfsys文件;⑧初始化用户打开文件表,将表项0分派给根目次文件应用,并填写根目次文件的相干信息,因为根目次没有上级目次,所以表项中的dirno和diroff分离置为5（根目次地点肇端块号）和0;并将ptrcurdir指针指向该用户打开文件表项.⑨将当前目次设置为根目次.3. 磁盘格局化函数my_format()（1）对应敕令: my_format（2）敕令挪用格局: my_format（3）函数设计格局: void my_format()（4）功效: 对虚拟磁盘进行格局化,布局虚拟磁盘,树立根目次文件（或根目次区）.（5）输入: 无（6）输出: 无.（7）函数需完成的工作:①将虚拟磁盘第一个块作为引诱块,开端的8个字节是文件体系的魔数,记为“10101010”;在之后写入文件体系的描写信息,如FAT表大小及地位.根目次大小及地位.盘块大小.盘块数目.数据区开端地位等信息;②在引诱块后树立两张完全一样的FAT表,用于记载文件所占领的磁盘块及治理虚拟磁盘块的分派,每个FAT占领两个磁盘块;对于每个FAT中,前面5个块设置为已分派,后面995个块设置为余暇;③在第二张FAT后创建根目次文件root,将数据区的第1块（即虚拟磁盘的第6块）分派给根目次文件,在该磁盘上创建两个特别的目次项: “.”和“..”,其内容除了文件名不同之外,其他字段完全雷同.4. 更改当前目次函数my_cd()（1）对应敕令: my_cd（2）敕令挪用格局: my_cd dirname（3）函数设计格局: void my_cd(char *dirname)（4）功效: 转变当前目次到指定的名为dirname的目次.（5）输入:dirname: 新的当前目次的目次名;（6）输出: 无（7）函数需完成的工作:①挪用my_open()打开指定目次名的父目次文件,并挪用do_read()读入该父目次文件内容到内存中;②在父目次文件中检讨新的当前目次名是否消失,假如消失则转③,不然返回,并显示出错信息;③挪用my_close()封闭①中打开的父目次文件;④挪用my_close()封闭原当前目次文件;⑤假如新的当前目次文件没有打开,则打开该目次文件;并将ptrcurdir指向该打开文件表项;⑥设置当前目次为该目次.5. 创建子目次函数my_mkdir()（1）对应敕令: my_mkdir（2）敕令挪用格局: my_ mkdir dirname（3）函数设计格局: void my_mkdir(char *dirname)（4）功效: 在当前目次下创建名为dirname的子目次.（5）输入:dirname：新建目次的目次名.（6）输出: 无.（7）函数需完成的工作:①挪用do_read()读入当前目次文件内容到内存,检讨当前目次下新建目次文件是否重名,若重名则返回,并显示错误信息;②为新建子目次文件分派一个余暇打开文件表项,假如没有余暇表项则返回-1,并显示错误信息;③检讨FAT是否有余暇的盘块,如有则为新建目次文件分派一个盘块,不然释放①平分派的打开文件表项,返回,并显示错误信息;④在当前目次中为新建目次文件查找一个余暇的目次项或为其追加一个新的目次项;需修正当前目次文件的长度信息,并将当前目次文件的用户打开文件表项中的fcbstate置为1;⑤预备好新建目次文件的FCB的内容,文件的属性为目次文件,以笼罩写方法挪用do_write()将其填写到对应的空目次项中;⑥在新建目次文件所分派到的磁盘块中树立两个特别的目次项“.”和“..”目次项,方法是: 起首在用户空间中预备好内容,然后以截断写或者笼罩写方法挪用do_write()将其写到③平分派到的磁盘块中;⑦返回.6. 删除子目次函数rmdir()（1）对应敕令: my_ rmdir（2）敕令挪用格局: my_ rmdir dirname（1）函数设计格局: void my_rmdir(char *dirname)（2）功效: 在当前目次下删除名为dirname的子目次.（3）输入:dirname：欲删除目次的目次名.（4）输出: 无.（5）函数需完成的工作:①挪用do_read()读入当前目次文件内容到内存,检讨当前目次下欲删除目次文件是否消失,若不消失则返回,并显示错误信息;②检讨欲删除目次文件是否为空（除了“.”和“..”外没有其他子目次和文件）,可依据其目次项中记载的文件长度来断定,若不为空则返回,并显示错误信息;③检讨该目次文件是否已经打开,若已打开则挪用my_close()封闭掉落;④收受接管该目次文件所占领的磁盘块,修正FAT;⑤从当前目次文件中清空该目次文件的目次项,且free字段置为0: 以笼罩写方法挪用do_write()来实现;⑥修正当前目次文件的用户打开表项中的长度信息,并将表项中的fcbstate置为1;⑦返回.7. 显示目次函数my_ls()（1）对应敕令: my_ls（2）敕令挪用格局: my_ls（3）函数设计格局: void my_ls(void)（4）功效: 显示当前目次的内容（子目次和文件信息）.（5）输入: 无（6）输出: 无（7）函数需完成的工作:①挪用do_read()读出当前目次文件内容到内存;②将读出的目次文件的信息按照必定的格局显示到屏幕上;③返回.8. 创建文件函数my_create()（1）对应敕令: my_create（2）敕令挪用格局: my_create filename（3）函数设计格局: int my_create (char *filename)（4）功效: 创建名为filename的新文件.（5）输入:filename：新建文件的文件名,可能包含路径.（6）输出: 若创建成功,返回该文件的文件描写符（文件打开表中的数组下标）;不然返回-1.（7）函数需完成的工作:①为新文件分派一个余暇打开文件表项,假如没有余暇表项则返回-1,并显示错误信息;②若新文件的父目次文件还没有打开,则挪用my_open()打开;若打开掉败,则释放①中为新建文件分派的余暇文件打开表项,返回-1,并显示错误信息;③挪用do_read()读出该父目次文件内容到内存,检讨该目次下新文件是否重名,若重名则释放①平分派的打开文件表项,并挪用my_close()封闭②中打开的目次文件;然后返回-1,并显示错误信息;④检讨FAT是否有余暇的盘块,如有则为新文件分派一个盘块,不然释放①平分派的打开文件表项,并挪用my_close()封闭②中打开的目次文件;返回-1,并显示错误信息;⑤在父目次中为新文件查找一个余暇的目次项或为其追加一个新的目次项;需修正该目次文件的长度信息,并将该目次文件的用户打开文件表项中的fcbstate置为1;⑥预备好新文件的FCB的内容,文件的属性为数据文件,长度为0,以笼罩写方法挪用do_write()将其填写到⑤平分派到的空目次项中;⑦为新文件填写①平分派到的余暇打开文件表项,fcbstate字段值为0,读写指针值为0;⑧挪用my_close()封闭②中打开的父目次文件;⑨将新文件的打开文件表项序号作为其文件描写符返回.9. 删除文件函数my_rm()（1）对应敕令: my_rm（2）敕令挪用格局: my_rm filename（3）函数设计格局: void my_rm(char *filename)（4）功效: 删除名为filename的文件.（5）输入:filename：欲删除文件的文件名,可能还包含路径.（6）输出: 无.（7）函数需完成的工作:①若欲删除文件的父目次文件还没有打开,则挪用my_open()打开;若打开掉败,则返回,并显示错误信息;②挪用do_read()读出该父目次文件内容到内存,检讨该目次下欲删除文件是否消失,若不消失则返回,并显示错误信息;③检讨该文件是否已经打开,若已打开则封闭掉落;④收受接管该文件所占领的磁盘块,修正FAT;⑤从文件的父目次文件中清空该文件的目次项,且free字段置为0: 以笼罩写方法挪用do_write()来实现;;⑥修正该父目次文件的用户打开文件表项中的长度信息,并将该表项中的fcbstate置为1;⑦返回.10. 打开文件函数my_open()（1）对应敕令: my_open（2）敕令挪用格局: my_open filename（3）函数设计格局: int my_open(char *filename)（4）功效: 打开当前目次下名为filename的文件.（5）输入:filename: 欲打开文件的文件名（6）输出: 若打开成功,返回该文件的描写符（在用户打开文件表中表项序号）;不然返回-1.（7）函数需完成的工作:①检讨该文件是否已经打开,若已打开则返回-1,并显示错误信息;②挪用do_read()读出父目次文件的内容到内存,检讨该目次下欲打开文件是否消失,若不消失则返回-1,并显示错误信息;③检讨用户打开文件表中是否有空表项,如有则为欲打开文件分派一个空表项,若没有则返回-1,并显示错误信息;④为该文件填写空白用户打开文件表表项内容,读写指针置为0;⑤将该文件所分派到的空白用户打开文件表表项序号（数组下标）作为文件描写符fd返回.11. 封闭文件函数my_close()（1）对应敕令: my_close（2）敕令挪用格局: my_close fd（3）函数设计格局: void my_close(int fd)（4）功效: 封闭前面由my_open()打开的文件描写符为fd的文件.（5）输入:fd：文件描写符.（6）输出: 无.（7）函数需完成的工作:①检讨fd的有用性（fd不能超出用户打开文件表地点数组的最大下标）,假如无效则返回-1;②检讨用户打开文件表表项中的fcbstate字段的值,假如为1则须要将该文件的FCB的内容保存到虚拟磁盘上该文件的目次项中,方法是: 打开该文件的父目次文件,以笼罩写方法挪用do_write()将欲封闭文件的FCB 写入父目次文件的响应盘块中;③收受接管该文件占领的用户打开文件表表项（进行清空操作）,并将topenfile字段置为0;④返回.12. 写文件函数my_write()（1）对应敕令: my_write（2）敕令挪用格局: my_write fd（3）函数设计格局: int my_write(int fd)（4）功效: 将用户经由过程键盘输入的内容写到fd所指定的文件中.磁盘文件的读写操作都必须以完全的数据块为单位进行,在写操作时,先将数据写在缓冲区中,缓冲区的大小与磁盘块的大小雷同,然后再将缓冲区中的数据一次性写到磁盘块中;读出时先将一个磁盘块中的内容读到缓冲区中,然后再传送到用户区.本实例为了轻便起见,没有设置缓冲区治理,只是在读写文件时由用户应用malloc()申请一块空间作为缓冲区,读写操作停止后应用free()释放掉落.写操作常有三种方法: 截断写.笼罩写和追加写.截断写是废弃本来文件的内容,从新写文件;笼罩写是修正文件在当前读写指针所指的地位开端的部分内容;追加写是在原文件的最后添加新的内容.在本实例中,输入写文件敕令后,体系会消失提醒让用户选择个中的一种写方法,并将随后键盘输入的内容按照所选的方法写到文件中,键盘输入内容经由过程CTR+Z键（或其他设定的键）停止.（5）输入:fd: open()函数的返回值,文件的描写符;（6）输出: 现实写入的字节数.（7）函数需完成的工作:①检讨fd的有用性（fd不能超出用户打开文件表地点数组的最大下标）,假如无效则返回-1,并显示出错信息;②提醒并等待用户输入写方法: （1: 截断写;2: 笼罩写;3: 追加写）③假如用户请求的写方法是截断写,则释放文件除第一块外的其他磁盘空间内容（查找并修正FAT表）,将内存用户打开文件表项中文件长度修正为0,将读写指针置为0并转④;假如用户请求的写方法是追加写,则修正文件的当前读写指针地位到文件的末尾,并转④;假如写方法是笼罩写,则直接转④;④提醒用户: 全部输入内容经由过程CTR+Z键（或其他设定的键）停止;用户可分多次输入写入内容,每次用回车停止;⑤等待用户从键盘输入文件内容,并将用户的本次输入内容保存到一暂时变量text[]中,请求每次输入以回车停止,全体停止用CTR+Z键（或其他设定的键）;⑥挪用do_write()函数将经由过程键盘键入的内容写到文件中.⑦假如do_write()函数的返回值为非负值,则将现实写入字节数增长do_write()函数返回值,不然显示出错信息,并转⑨;⑧假如text[]中最后一个字符不是停止字符CTR+Z,则转⑦持续进行写操作;不然转⑨;⑨假如当前读写指针地位大于用户打开文件表项中的文件长度,则修正打开文件表项中的文件长度信息,并将fcbstate置1;⑩返回现实写入的字节数.13. 现实写文件函数do_write()（1）对应敕令: 无（2）敕令挪用格局: 无（3）函数设计格局: int my_write(int fd,char *text,int len,char wstyle)（4）功效: 被写文件函数my_write()挪用,用来将键盘输入的内容写到响应的文件中去.（5）输入:fd: open()函数的返回值,文件的描写符;text: 指向要写入的内容的指针;len: 本次请求写入字节数wstyle: 写方法（6）输出: 现实写入的字节数.（7）函数需完成的工作:①用malloc()申请1024B的内存空间作为读写磁盘的缓冲区buf,申请掉败则返回-1,并显示出错信息;②将读写指针转化为逻辑块块号和块内偏移off,并应用打开文件表表项中的首块号及FAT表的相干内容将逻辑块块号转换成对应的磁盘块块号blkno;假如找不到对应的磁盘块,则须要检索FAT为该逻辑块分派一新的磁盘块,并将对应的磁盘块块号blkno登记到FAT中,若分派掉败,则返回-1,并显示出错信息;③假如是笼罩写,或者假如当前读写指针所对应的块内偏移off不等于0,则将块号为blkno的虚拟磁盘块全体1024B的内容读到缓冲区buf中;不然便用ASCII码0清空buf;④将text中未写入的内容暂存到缓冲区buff的第off字节开端的地位,直到缓冲区满,或者吸收到停止字符CTR+Z为止;将本次写入字节数记载到tmplen中;⑤将buf中1024B的内容写入到块号为blkno的虚拟磁盘块中;⑥将当前读写指针修正为本来的值加上tmplen;并将本次现实写入的字节数增长tmplen;⑦假如tmplen小于len,则转②持续写入;不然转⑧;⑧返回本次现实写入的字节数.14. 读文件函数my_read()（1）对应敕令: my_read（2）敕令挪用格局: my_read fd len（3）函数设计格局: int myread (int fd, int len)（4）功效: 读出指定文件中从读写指针开端的长度为len的内容到用户空间中.（5）输入:fd: open()函数的返回值,文件的描写符;len: 要从文件中读出的字节数.（6）输出: 现实读出的字节数.（7）函数需完成的工作:①界说一个字符型数组text[len],用来吸收用户从文件中读出的文件内容;②检讨fd的有用性（fd不能超出用户打开文件表地点数组的最大下标）,假如无效则返回-1,并显示出错信息;③挪用do_read()将指定文件中的len字节内容读出到text[]中;④假如do_read()的返回值为负,则显示出错信息;不然将text[]中的内容显示到屏幕上;⑤返回.15. 现实读文件函数do_read()（1）对应敕令: 无（2）敕令挪用格局: 无（3）函数设计格局: int do_read (int fd, int len,char *text)（4）功效: 被my_read()挪用,读出指定文件中从读写指针开端的长度为len的内容到用户空间的text中. （5）输入:fd: open()函数的返回值,文件的描写符;len: 请求从文件中读出的字节数.text: 指向存放读出数据的用户区地址（6）输出: 现实读出的字节数.（7）函数需完成的工作:①应用malloc()申请1024B空间作为缓冲区buf,申请掉败则返回-1,并显示出错信息;②将读写指针转化为逻辑块块号及块内偏移量off,应用打开文件表表项中的首块号查找FAT表,找到该逻辑块地点的磁盘块块号;将该磁盘块块号转化为虚拟磁盘上的内存地位;③将该内存地位开端的1024B（一个磁盘块）内容读入buf中;④比较buf中从偏移量off开端的残剩字节数是否大于等于应读写的字节数len,假如是,则将从off开端的buf中的len长度的内容读入到text[]中;不然,将从off开端的buf中的残剩内容读入到text[]中;⑤将读写指针增长④中已读字节数,将应读写的字节数len减去④中已读字节数,若len大于0,则转②;不然转⑥;⑥应用free()释放①中申请的buf.⑦返回现实读出的字节数.16.退出文件体系函数my_exitsys()（1）对应敕令: my_exitsys（2）敕令挪用格局: my_ exitsys（1）函数设计格局: void my_exitsys()（2）功效: 退出文件体系.（3）输入: 无（4）输出: 无.（5）函数需完成的工作:①应用C库函数fopen()打开磁盘上的myfsys文件;②将虚拟磁盘空间中的所有内容保存到磁盘上的myfsys文件中;③应用c说话的库函数fclose()封闭myfsys文件;④撤销用户打开文件表,释放其内存空间⑤释放虚拟磁盘空间.流程图#include <string.h>#include <time.h>#define BLOCKSIZE 1024 // 磁盘块大小#define SIZE 1024000 // 虚拟磁盘空间大小#define END 65535 // FAT中的文件停止标志#define FREE 0 // FAT中盘块余暇标志#define ROOTBLOCKNUM 2 // 根目次区所占盘块数#define MAXOPENFILE 10 // 最多同时打开文件个数t#define MAXTEXT 10000/* 文件掌握块 */typedef struct FCB{char filename[8]; // 文件名char exname[3]; // 文件扩大名unsigned char attribute; // 文件属性字段,值为0时表示目次文件,值为1时表示数据文件unsigned short time; // 文件创建时光unsigned short date; // 文件创建日期unsigned short first; // 文件肇端盘块号unsigned long length; // 文件长度char free; // 表示目次项是否为空,若值为0,表示空,值为1,表示已分派}fcb;/* 文件分派表 */typedef struct FAT{unsigned short id; // 磁盘块的状况（余暇的,最后的,下一个）}fat;/* 用户打开文件表 */typedef struct USEROPEN{char filename[8]; // 文件名char exname[3]; // 文件扩大名unsigned char attribute;//文件属性字段,值为0时表示目次文件,值为1时表示数据文件unsigned short time; // 文件创建时光unsigned short date; // 文件创建日期unsigned short first; // 文件肇端盘块号unsigned long length;//文件长度（对数据文件是字节数,对目次文件可所以目次项个数）char free; // 表示目次项是否为空,若值为0,表示空,值为1,表示已分派unsigned short dirno; // 响应打开文件的目次项在父目次文件中的盘块号int diroff; // 响应打开文件的目次项在父目次文件的dirno盘块中的目次项序号char dir[80]; // 响应打开文件地点的路径名,如许便利快速检讨出指定文件是否已经打开int father; // 父目次在打开文件表项的地位int count; // 读写指针在文件中的地位,文件的总字符数char fcbstate; // 是否修正了文件的FCB的内容,假如修正了置为1,不然为0char topenfile; // 表示该用户打开表项是否为空,若值为0,表示为空,不然表示已被某打开文件占领}useropen;/* 引诱块 */typedef struct BLOCK0{char magic[10]; // 文件体系魔数char information[200];//存储一些描写信息,如磁盘块大小.磁盘块数目.最多打开文件数等 unsigned short root; // 根目次文件的肇端盘块号unsigned char *startblock; // 虚拟磁盘上数据区开端地位}block0;unsigned char *myvhard; // 指向虚拟磁盘的肇端地址useropen openfilelist[MAXOPENFILE]; // 用户打开文件表数组int curdir; // 用户打开文件表中的当前目次地点打开文件表项的地位char currentdir[80]; // 记载当前目次的目次名（包括目次的路径）unsigned char* startp; // 记载虚拟磁盘上数据区开端地位char myfilename[] = "myfilesys";//文件体系的文件名void startsys(); // 进入文件体系void my_format(); // 磁盘格局化void my_cd(char *dirname); // 更改当前目次void my_mkdir(char *dirname); // 创建子目次void my_rmdir(char *dirname); // 删除子目次void my_ls(); // 显示目次void my_create (char *filename); // 创建文件void my_rm(char *filename); // 删除文件int my_open(char *filename); // 打开文件int my_close(int fd); // 封闭文件int my_write(int fd); // 写文件int do_write(int fd, char *text, int len, char wstyle); // 现实写文件int my_read (int fd, int len); // 读文件int do_read (int fd, int len,char *text); // 现实读文件void my_exitsys(); // 退出文件体系unsigned short findblock(); // 查找余暇盘块int findopenfile(); // 查找余暇文件表项void startsys(){FILE *fp;unsigned char buf[SIZE];fcb *root;int i;myvhard = (unsigned char *)malloc(SIZE);//申请虚拟磁盘空间memset(myvhard, 0, SIZE);//将myvhard中前SIZE个字节用 0 调换并返回 myvhard if((fp = fopen(myfilename, "r")) != NULL){fread(buf, SIZE, 1, fp);//将二进制文件读取到缓冲区fclose(fp);if(strcmp(((block0 *)buf)->magic, "10101010")){printf("myfilesys is not exist,begin to creat the file...\n");my_format();}else{for(i = 0; i < SIZE; i++)myvhard[i] = buf[i];}}else{printf("myfilesys is not exist,begin to creat the file...\n");my_format();}root = (fcb *)(myvhard + 5 * BLOCKSIZE);strcpy(openfilelist[0].filename, root->filename);strcpy(openfilelist[0].exname, root->exname);openfilelist[0].attribute = root->attribute;openfilelist[0].time = root->time;openfilelist[0].date = root->date;openfilelist[0].first = root->first;openfilelist[0].length = root->length;openfilelist[0].free = root->free;openfilelist[0].dirno = 5;openfilelist[0].diroff = 0;strcpy(openfilelist[0].dir, "\\root\\");openfilelist[0].father = 0;openfilelist[0].count = 0;openfilelist[0].fcbstate = 0;openfilelist[0].topenfile = 1;for(i = 1; i < MAXOPENFILE; i++)openfilelist[i].topenfile = 0;curdir = 0;strcpy(currentdir, "\\root\\");startp = ((block0 *)myvhard)->startblock;}void my_format(){FILE *fp;fat *fat1, *fat2;block0 *blk0;time_t now;struct tm *nowtime;fcb *root;int i;blk0 = (block0 *)myvhard;fat1 = (fat *)(myvhard + BLOCKSIZE);fat2 = (fat *)(myvhard + 3 * BLOCKSIZE);root = (fcb *)(myvhard + 5 * BLOCKSIZE);strcpy(blk0->magic, "10101010");strcpy(blk0->information, "My FileSystem Ver 1.0 \n Blocksize=1KB Whole size=1000KB Blocknum=1000 RootBlocknum=2\n");blk0->root = 5;blk0->startblock = (unsigned char *)root;for(i = 0; i < 5; i++){fat1->id = END;fat2->id = END;fat1++;fat2++;}fat1->id = 6;fat2->id = 6;fat1++;fat2++;fat1->id = END;fat2->id = END;fat1++;fat2++;for(i = 7; i < SIZE / BLOCKSIZE; i++){fat1->id = FREE;fat2->id = FREE;fat1++;fat2++;}now = time(NULL);nowtime = localtime(&now);strcpy(root->filename, ".");strcpy(root->exname, "");root->attribute = 0x28;root->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;root->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday; root->first = 5;root->length = 2 * sizeof(fcb);root->free = 1;root++;now = time(NULL);nowtime = localtime(&now);strcpy(root->filename, "..");strcpy(root->exname, "");root->attribute = 0x28;root->time = nowtime->tm_hour * 2048 + nowtime->tm_min * 32 + nowtime->tm_sec / 2;root->date = (nowtime->tm_year - 80) * 512 + (nowtime->tm_mon + 1) * 32 + nowtime->tm_mday; root->first = 5;root->length = 2 * sizeof(fcb);root->free = 1;fp = fopen(myfilename, "w");fwrite(myvhard, SIZE, 1, fp);fclose(fp);}void my_cd(char *dirname){char *dir;int fd;dir = strtok(dirname, "\\");//分化字符串为一组字符串.dirname为要分化的字符串,"\\"为分隔符字符串 if(strcmp(dir, ".") == 0)return;else if(strcmp(dir, "..") == 0){if(curdir)curdir = my_close(curdir);return;}else if(strcmp(dir, "root") == 0){while(curdir)curdir = my_close(curdir);dir = strtok(NULL, "\\");}while(dir)。
操作系统 文件系统课程设计
操作系统文件系统课程设计
操作系统文件系统课程设计主要涉及以下几个方面：
1. 实现基于模块的文件系统：
- 修改ext3或ext4的源代码
- 动态加载和卸载新的文件系统
- 修改文件系统的名称，优化文件写操作
2. 新增Linux驱动程序：
- 增加一个驱动程序（使用内存模拟设备）
- 动态加载和卸载新的驱动
- 通过程序或命令行使用该驱动
- 保存和读取数据
3. 统计Linux系统缺页的次数：
- 在内核中实现缺页次数统计
- 编译并安装新内核
- 建立内核模块，通过/proc实现用户态查看缺页次数
4. 模拟磁盘文件系统实现：
- 设计一个简单的文件系统，用文件模拟磁盘，用数组模拟缓冲区
- 支持多级目录结构，支持文件的绝对读路径
- 实现建立目录、列目录、删除空目录、建立文件、删除文件、显示文件内容、打开文件、读文件、写文件、关闭文件、改变文件属性等命令建议根据以上概述，结合实际需求和兴趣，选择相应的题目进行课程设计。
操作系统-文件系统-课程设计报告--后附源代码
目录1 课程设计简介 (1)1.1 课程设计的目的 (1)1.2 课程设计内容 (1)2 数据结构的设计 (2)2.1 预定义 (2)2.2 结构体 (2)2.3 全局变量和函数 (2)3 功能模块（或算法）描述 (5)3.1 模块划分 (4)3.2 模块流程图 (6)4 程序运行结果 (8)5心得体会 (9)参考文献 (10)附源代码 (11)1 课程设计简介1.1 课程设计的目的课程设计目的使学生熟悉文件管理系统的设计方法；加深对所学各种文件操作的了解及其操作方法的特点。
通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识, 加深对教材中的重要算法的理解。
同时通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。
1.2 课程设计内容课程设计内容设计一个简单的多用户文件系统。
即①在系统中用一个文件来模拟一个磁盘；②此系统至少有：Create、delete、open、close、read、write等和部分文件属性的功能。
③实现这个文件系统。
④能实际演示这个文件系统。
基本上是进入一个界面（此界面就是该文件系统的界面）后，可以实现设计的操作要求。
1）设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。
2）程序采用二级文件目录（即设置主目录MFD）和用户文件目录（UFD）。
另外，为打开文件设置了运行文件目录（AFD）。
3）为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。
4）因系统小，文件目录的检索使用了简单的线性搜索。
5）文件保护简单使用了三位保护码：允许读写执行、对应位为1，对应位为0，则表示不允许读写、执行。
6）程序中使用的主要设计结构如下：主文件目录和用户文件目录（MFD、UFD），打开文件目录（AFD）即运行文件目录，如图5.1所示。
2 数据结构的设计2.1 预定义#define BLOCKSIZ 512 //磁盘块的大小#define DATABLKNUM 512 //数据块的数目#define BLKGRUPNUM 50 //数据块组包含多少数据块#define P_N_BLOCKS 15 //inode节点中指向数据块的指针个数#define GROUPNUM DA TABLKNUM/BLKGRUPNUM+1 //数据块组组数#define DINODESIZ 512 //磁盘i结点区的大小（空间32×512）#define DINODENUM 32 //磁盘i结点区的块数#define SYSOPENFILE 40#define DIRNUM 32 //一个目录下的最多目录和文件的总和数#define DIRSIZ 14 //文件、目录名的长度(字节)#define UPWDSIZ 15 //密码的长度#define UNAMSIZ 15 //用户名的长度#define PWDSIZ sizeof(struct pwd) //密码结构的长度#define PWDNUM BLOCKSIZ/PWDSIZ //密码数据空间的大小（pwd为单位）#define NOFILE 20 //一个用户最多可以打开的文件数目#define DINODESTART 4*BLOCKSIZ//i结点区的开始地址-inodes table ，1引导2超块3block bitmap 4inode bitmap#define DATASTAR T (2+DINODENUM)*BLOCKSIZ //数据区的开始地址#define DA TASTAR TNO 36 //数据区开始指针#define DIMODE_EMPTY 00000/*可以用的空间*/#define DIMODE_FILE 00001#define DIMODE_DIR 00002#define DIMODE_P ASSWD00004#define GRUP_0 0 //管理员组#define GRUP_1 1#define GRUP_2 2#define GRUP_4 42.2 结构体//磁盘i结点结构，struct inode{// char di_name[DIRSIZ];unsigned __int16 di_ino; /*磁盘i节点标识*/unsigned __int16 di_number; /*关联文件数，当为0时表示删除文件*/unsigned __int16 di_mode; /*存取权限*/unsigned __int16 di_uid; /*磁盘i节点用户id*/unsigned __int16 di_gid; /*磁盘i节点权限组id*/ //1管理员组2用户组unsigned __int32 di_size; /*文件大小*/unsigned __int32 di_ctime; /* Creation time */unsigned __int32 di_mtime; /* Modification time */unsigned __int16 di_block[P_N_BLOCKS]; /* 一组block 指针*/};// 目录项结构struct direct{char d_name[DIRSIZ]; /*目录名（14字节）*/__int16 d_ino; /*目录号*/};//超级快结构struct super_block{unsigned __int16 s_inodes_count; /* inodes 计数*/unsigned __int16 s_blocks_count; /* blocks 计数*/unsigned __int16 s_r_blocks_count; /* 保留的blocks 计数*/unsigned __int16 s_free_blocks_count; // 空闲的blocks 计数unsigned __int16 s_free_inodes_count; /* 空闲的inodes 计数*/unsigned __int16 s_free_blocks_group[GROUPNUM];//新增一个数组来记录每个数据块组中的空闲数据块计数unsigned __int16 s_first_data_block; /* 第一个数据block */unsigned __int16 s_log_block_size; /* block 的大小*/unsigned __int16 s_blocks_per_group; /* 每block group 的block 数量*/unsigned __int16 s_inodes_per_group; /* 每block group 的inode 数量*/};// 用户密码struct pwd{unsigned __int8 p_uid;unsigned __int8 p_gid;char username[UNAMSIZ];/*用户名新加的*/char password[UPWDSIZ];};// 目录结构struct dir{struct direct direct[DIRNUM];__int16 size;};2.3 全局变量和函数// 全局变量unsigned __int8 di_bitmap[DINODENUM]; // 硬盘inode节点位图1表示已使用0表示未使用unsigned __int8 bk_bitmap[DATABLKNUM]; // 数据块block位图struct super_block filsys; //超级块struct pwd pwd[PWDNUM];FILE *fd; //文件指针struct inode *cur_inode; //i节点当前目录指针struct inode *inodetemp; //i节点指针const char fsystemname[20]="Linux.EXT2"; //模拟硬盘的文件名struct direct dir_buf[BLOCKSIZ / sizeof(struct direct)]; //目录数组char cmdhead[20];//cmd 的头表示所在哪个文件夹、int i_lock=0;//inode位图锁可能会多线程int b_lock=0;//block位图锁struct pwd *cur_user;/* 全局函数*/extern int Format();//格式化磁盘extern int Install();//启动，安装文件系统struct inode * read_inode(int);//install里面读取文件dinodestruct direct * read_dir_data(int);//读取存储文件夹的物理块extern void showdir();//命令dirint Enterdir(char[]);//进入某个文件夹命令-- cd 文件名int Fd_dirfile(char[]);//查找当前目录里的文件没找到返回-1 找到返回inode号int Iscmd(char[]);//判断是否两个字符串的命令void two_cmd(char[],char[]);//两个字符串的命令int creat(char[]);//创建文件void changeinode();//交换指针char * ReadFile(char[]);//读取文件int mkdir(char[]);//创建文件夹void showbitmap();//显示位图int deletefd(char[]);//删除文件int editfile(char[]);//编辑文件int rename(char[]);//重命名void showhelp();//命令帮助void login();void logout();int access();//权限判断/*磁盘i节点的分配与释放（当一个新文件被建立的时候，在给该文件分配磁盘存储区之前，应为该文件分配存放该文件说明信息的磁盘i节点，当从文件系统中删除某个文件时，应首先删除它的磁盘i节点项。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计文件系统#include stdio.h#include memory.h#include string#include iostream using namespace std；struct FCB{char fname[16]；//文件名int type；//1代表普通文件2代表目录文件0表示空文件int size；//文件大小int fatherBlockNum；//当前的父目录盘块号int currentBlockNum；//当前的盘块void initialize(){strcpy(fname,"[message]")；type=0；size=0；fatherBlockNum=currentBlockNum=0；}}；const char*FilePath="C：\myfiles"；const int BlockSize=512；//盘块大小(可配置)const int OPEN_MAX=5；//能打开最多的文件数const int BlockCount=BlockSize/sizeof(int)；//盘块数const int DiskSize=BlockSize*BlockCount；//磁盘大小const int BlockFcbCount=BlockSize/sizeof(FCB)；//目录文件的最多FCB数//const int IOBUF_SIZE=512；//char IOBuffer[IOBUF_SIZE]；int OpenFileCount=0；struct OPENLIST//用户文件打开表{int files；//当前打开文件数FCB f[OPEN_MAX]；//FCB拷贝OPENLIST(){files=0；for(int i=0；i OPEN_MAX；i++){f[i].fatherBlockNum=-1；//为分配打开f[i].type=0；}}}；struct dirFile{struct FCB fcb[BlockFcbCount]；void init(int _FatherBlockNum,int _CurrentBlockNum,char*name)//父块号，当前块号，目录名{strcpy(fcb[0].fname,name)；//本身的FCBfcb[0].fatherBlockNum=_FatherBlockNum；fcb[0].currentBlockNum=_CurrentBlockNum；fcb[0].type=2；//标记目录文件for(int i=1；i BlockFcbCount；i++){fcb[i].fatherBlockNum=_CurrentBlockNum；//标记为子项fcb[i].type=0；//标记为空白项}}}；struct DISK{int FAT1[BlockCount]；//FAT1 int FAT2[BlockCount]；//FAT2 struct dirFile root；//根目录char data[BlockCount-3][BlockSize]；void format(){memset(FAT1,0,BlockCount)；//FAT1 memset(FAT2,0,BlockCount)；//FAT2 FAT1[0]=FAT1[1]=FAT1[2]=-2；//0,1,2盘块号依次代表FAT1,FAT2,根目录区FAT2[0]=FAT2[1]=FAT2[2]=-2；//FAT作备份root.init(2,2,"G：\")；//根目录区memset(data,0,sizeof(data))；//数据区}}；FILE*fp；//磁盘文件地址char*BaseAddr；//虚拟磁盘空间基地址string currentPath="G：\"；//当前路径int current=2；//当前目录的盘块号string cmd；//输入指令struct DISK*osPoint；//磁盘操作系统指针char command[16]；//文件名标识struct OPENLIST*openlist；//用户文件列表指针int format()；int mkdir(char*sonfname)；int rmdir(char*sonfname)；int create(char*name)；int listshow()；int delfile(char*name)；int changePath(char*sonfname)；int write(char*name)；int exit()；int open(char*file)；int close(char*file)；int read(char*file)；int format(){current=2；currentPath="G：\"；//当前路径osPoint-format()；//打开文件列表初始化delete openlist；openlist=new OPENLIST；fp=fopen(FilePath,"w+")；fwrite(BaseAddr,sizeof(char),DiskSize,fp)；fclose(fp)；printf("--\n\n")；return 1；}int mkdir(char*sonfname){//判断是否有重名//寻找空白子目录项//寻找空白盘块号//当前目录下增加该子目录项//分配子目录盘块，并且初始化//修改fat表int i,temp,iFAT；struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；for(i=1；i BlockFcbCount；i++){if(dir-fcb[i].type==2&&strcmp(dir-fcb[i].fname,sonfname)==0) {printf("该文件夹下已经有同名的文件夹存在了！\n")；return 0；}}//查找空白fcb序号for(i=1；i BlockFcbCount；i++){if(dir-fcb[i].type==0)break；}if(i==BlockFcbCount){printf("该目录已满！请选择新的目录下创建！\n")；return 0；}temp=i；for(i=3；i BlockCount；i++){if(osPoint-FAT1[i]==0)break；}if(i==BlockCount){printf("磁盘已满！\n")；return 0；}iFAT=i；osPoint-FAT1[iFAT]=osPoint-FAT2[iFAT]=2；//2表示分配给下级目录文件//填写该分派新的盘块的参数strcpy(dir-fcb[temp].fname,sonfname)；dir-fcb[temp].type=2；dir-fcb[temp].fatherBlockNum=current；dir-fcb[temp].currentBlockNum=iFAT；//初始化子目录文件盘块dir=(struct dirFile*)(osPoint-data[iFAT-3])；//定位到子目录盘块号dir-init(current,iFAT,sonfname)；//iFAT是要分配的块号，这里的current用来指要分配的块的父块号printf("---\n\n")；return 1；}int rmdir(char*sonfname){//if(子目录不存在)return error//if(子目录不是空文件夹)return error//回收子目录磁盘块号b(修改fat)//回收子目录占据目录项int i,temp,j；//确保当前目录下有该文件,并记录下该FCB下标struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；for(i=1；i BlockFcbCount；i++){//查找该目录文件if(dir-fcb[i].type==2&&strcmp(dir-fcb[i].fname,sonfname)==0) {break；}}temp=i；if(i==BlockFcbCount){printf("当前目录下不存在该子目录！\n")；return 0；}j=dir-fcb[temp].currentBlockNum；struct dirFile*sonDir；//当前子目录的指针sonDir=(struct dirFile*)(osPoint-data[j-3])；for(i=1；i BlockFcbCount；i++)//查找子目录是否为空目录{if(sonDir-fcb[i].type！=0){printf("该文件夹为非空文件夹,为确保安全，请清空后再删除！\n")；return 0；}}osPoint-FAT1[j]=osPoint-FAT2[j]=0；//fat清空char*p=osPoint-data[j-3]；//格式化子目录memset(p,0,BlockSize)；dir-fcb[temp].initialize()；//回收子目录占据目录项printf("---\n\n")；return 1；}int create(char*name){int i,iFAT；//temp,int emptyNum=0,isFound=0；//空闲目录项个数struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；//查看目录是否已满//为了避免同名的文本文件for(i=1；i BlockFcbCount；i++){if(dir-fcb[i].type==0&&isFound==0){emptyNum=i；isFound=1；}else if(dir-fcb[i].type==1&&strcmp(dir-fcb[i].fname,name)==0) {printf("无法在同一目录下创建同名文件！\n")；return 0；}}if(emptyNum==0){printf("已经达到目录项容纳上限，无法创建新目录！\n")；return 0；}//查找FAT表寻找空白区，用来分配磁盘块号j for(i=3；i BlockCount；i++){if(osPoint-FAT1[i]==0)break；}if(i==BlockCount){printf("磁盘已满！\n")；return 0；}iFAT=i；//分配磁盘块osPoint-FAT1[iFAT]=osPoint-FAT2[iFAT]=1；//填写该分派新的盘块的参数strcpy(dir-fcb[emptyNum].fname,name)；dir-fcb[emptyNum].type=1；dir-fcb[emptyNum].fatherBlockNum=current；dir-fcb[emptyNum].currentBlockNum=iFAT；dir-fcb[emptyNum].size=0；char*p=osPoint-data[iFAT-3]；memset(p,'#',BlockSize)；printf("--\n\n")；return 1；}int listshow(){int i,DirCount=0,FileCount=0；//搜索当前目录struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；for(i=1；i BlockFcbCount；i++){if(dir-fcb[i].type==1){//查找普通文件FileCount++；printf("%s文本文件.\n",dir-fcb[i].fname)；}if(dir-fcb[i].type==2){//查找目录文件DirCount++；printf("%s文件夹.\n",dir-fcb[i].fname)；}}printf("\n该目录下共有%d个文本文件,%d个文件夹\n\n",FileCount,DirCount)；printf("--\n\n")；return 1；}int delfile(char*name){int i,temp,j；//确保当前目录下有该文件,并且记录下它的FCB下标struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；for(i=1；i BlockFcbCount；i++)//查找该文件{if(dir-fcb[i].type==1&&strcmp(dir-fcb[i].fname,name)==0){break；}}if(i==BlockFcbCount){printf("当前目录下不存在该文件！\n")；return 0；}//从打开列表中删除close(name)；temp=i；j=dir-fcb[temp].currentBlockNum；//查找盘块号j osPoint-FAT1[j]=osPoint-FAT2[j]=0；//fat1,fat2表标记为空白char*p=osPoint-data[j-3]；memset(p,0,BlockSize)；//清除原文本文件的内容dir-fcb[temp].initialize()；//type=0；//标记该目录项为空文件printf("--\n\n")；return 1；}int changePath(char*sonfname){struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；if(strcmp(sonfname,".")==0){if(current==2){printf("你现已经在根目录下！\n")；return 0；}current=dir-fcb[0].fatherBlockNum；currentPath=currentPath.substr(0,currentPath.size()-strlen(dir-fcb[0].fname)-1)；return 1；}int i,temp；//确保当前目录下有该目录,并且记录下它的FCB下标for(i=1；i BlockFcbCount；i++){//查找该文件if(dir-fcb[i].type==2&&strcmp(dir-fcb[i].fname,sonfname)==0) {temp=i；break；}}if(i==BlockFcbCount){printf("不存在该目录！\n")；return 0；}//修改当前文件信息current=dir-fcb[temp].currentBlockNum；currentPath=currentPath+dir-fcb[temp].fname+"\"；printf("---\n\n")；return 1；}int exit(){//将所有文件都关闭//保存到磁盘上C：\myfiles fp=fopen(FilePath,"w+")；fwrite(BaseAddr,sizeof(char),DiskSize,fp)；fclose(fp)；//释放内存上的虚拟磁盘free(osPoint)；//释放用户打开文件表delete openlist；printf("---\n\n")；return 1；}int write(char*name){int i；char*startPoint,*endPoint；//在打开文件列表中查找file(还需要考虑同名不同目录文件的情况！)for(i=0；i OPEN_MAX；i++){if(strcmp(openlist-f[i].fname,name)==0){if(openlist-f[i].fatherBlockNum==current){break；}else{printf("该文件处于打开列表中，本系统只能改写当前目录下文件！\n")；return 0；}}}if(i==OPEN_MAX){printf("该文件尚未打开,请先打开后写入信息！\n")；return 0；}int active=i；int fileStartNum=openlist-f[active].currentBlockNum-3；startPoint=osPoint-data[fileStartNum]；endPoint=osPoint-data[fileStartNum+1]；printf("请输入文本以#号结束：\t")；char input；while(((input=getchar())！='#')){if(startPoint endPoint-1){*startPoint++=input；}else{printf("达到单体文件最大容量！")；*startPoint++='#'；break；}}return 1；}int read(char*file){int i,fileStartNum；char*startPoint,*endPoint；//struct dirFile*dir；//在打开文件列表中查找file(还需要考虑同名不同目录文件的情况！) for(i=0；i OPEN_MAX；i++){if(strcmp(openlist-f[i].fname,file)==0){if(openlist-f[i].fatherBlockNum==current){break；}else{printf("该文件处于打开列表中，本系统只能阅读当前目录下文件！\n")；return 0；}}}if(i==OPEN_MAX){printf("该文件尚未打开,请先打开后读取信息！\n")；return 0；}int active=i；//计算文件物理地址fileStartNum=openlist-f[active].currentBlockNum-3；startPoint=osPoint-data[fileStartNum]；endPoint=osPoint-data[fileStartNum+1]；//end_dir=(struct dirFile*)[BlockSize-1]；//q=(char*)end_dir；printf("该文件的内容为：")；while((*startPoint)！='#'&&(startPoint endPoint)){putchar(*startPoint++)；}printf("\n")；return 1；}int open(char*file)//打开文件{int i,FcbIndex；//确保没有打开过该文件=相同名字+相同目录for(i=0；i OPEN_MAX；i++){if(openlist-f[i].type==1&&strcmp(openlist-f[i].fname,file)==0&&openlist-f[i].fatherBlockNum==current) {printf("该文件已经被打开！\n")；return 0；}//确保有空的打开文件项if(openlist-files==OPEN_MAX){printf("打开文件数目达到上限！无法再打开新文件.\n")；return 0；}//确保当前目录下有该文件,并且记录下它的FCB下标struct dirFile*dir；//当前目录的指针if(current==2)dir=&(osPoint-root)；else dir=(struct dirFile*)(osPoint-data[current-3])；for(i=1；i BlockFcbCount；i++){//查找该文件if(dir-fcb[i].type==1&&strcmp(dir-fcb[i].fname,file)==0) {FcbIndex=i；break；}if(i==BlockFcbCount){printf("当前目录下不存在该文件！\n")；return 0；}//装载新文件进入打开文件列表,(FCB信息，文件数++)?难道名字过不来? openlist-f[OpenFileCount]=dir-fcb[FcbIndex]；//FCB拷贝openlist-files++；printf("文件打开成功！\n")；OpenFileCount++；return 1；}int close(char*file){//释放该文件所占内存//释放用户打开文件列表表项int i；//在打开文件列表中查找file(还需要考虑同名不同目录文件的情况！) for(i=0；i OPEN_MAX；i++){if((openlist-f[i].type=1)&&(strcmp(openlist-f[i].fname,file)==0)){if(openlist-f[i].fatherBlockNum==current){break；}else{printf("该文件已打开，但未在当前目录下，无法关闭！\n")；return 0；}}}if(i==OPEN_MAX){printf("该文件未在打开列表中！\n")；return 0；}int active=i；openlist-files--；openlist-f[active].initialize()；OpenFileCount--；printf("该文件已关闭！\n")；return 1；}void main(){printf("---Welcome To My Operate System Of File(FAT)---\n")；//使用说明书printf("\n以下是使用说明书：\n")；printf("--\n")；printf("||format：对磁盘格式化.||\n")；printf("||exit：安全退出该文件系统,保存信息.||\n")；printf("||mkdir dirname：创建子目录.||\n")；printf("||rmdir dirname：删除子目录.||\n")；printf("||ls dirname：显示当前目录下信息.||\n")；printf("||cd dirname：更改当前目录.||\n")；printf("||create filename：创建一个新文件,并且打开.||\n")；printf("||write filename：选择一个打开的文件写入信息||\n")；printf("||read filename：选择一个打开的文件读取信息.||\n")；printf("||rm filename：删除文件.||\n")；printf("||open filename：打开文件.||\n")；printf("||close filename：关闭文件.||\n")；printf("---\n\n")；//创建用户文件打开表openlist=new OPENLIST；//申请虚拟空间并且初始化BaseAddr=(char*)malloc(DiskSize)；//虚拟磁盘初始化osPoint=(struct DISK*)(BaseAddr)；//加载磁盘文件if((fp=fopen(FilePath,"r"))！=NULL){fread(BaseAddr,sizeof(char),DiskSize,fp)；printf("加载磁盘文件(%s)成功,现在可以进行操作了！\n\n",FilePath)；}else{printf("这是你第一次使用该文件管理系统！\t正在初始化.\n")；format()；printf("初始化已经完成,现在可以进行操作了！\n\n")；}printf("--\n\n")；while(1){cout currentPath；cin cmd；if(cmd=="format"){format()；}else if(cmd=="mkdir"){cin command；mkdir(command)；}else if(cmd=="rmdir"){rmdir(command)；}else if(cmd=="ls"){ listshow()；}else if(cmd=="cd"){cin command；changePath(command)；}else if(cmd=="create"){ cin command；create(command)；}else if(cmd=="write"){ cin command；write(command)；}else if(cmd=="read"){read(command)；}else if(cmd=="rm"){ cin command；delfile(command)；}else if(cmd=="open"){ cin command；open(command)；}else if(cmd=="close"){ cin command；close(command)；}else if(cmd=="exit"){ exit()；break；}else cout"无效指令,请重新输入："endl；}printf("Thank you for using my file system！\n")；}MSN空间完美搬家到新浪博客！特别声明：1：资料来源于互联网，版权归属原作者2：资料内容属于网络意见，与本账号立场无关3：如有侵权，请告知，立即删除。