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

合集下载

《操作系统》实验报告

《操作系统》实验报告一、实验目的操作系统是计算机系统中最为关键的组成部分之一，本次实验的主要目的是深入理解操作系统的基本原理和功能，通过实际操作和观察，熟悉操作系统的核心概念，包括进程管理、内存管理、文件系统和设备管理等，提高对操作系统的实际应用能力和问题解决能力。

二、实验环境本次实验在以下环境中进行：操作系统：Windows 10开发工具：Visual Studio 2019编程语言：C+＋三、实验内容1、进程管理实验进程是操作系统中最基本的执行单元。

在这个实验中，我们使用C+＋编写程序来创建和管理进程。

通过观察进程的创建、执行和结束过程，理解进程的状态转换和资源分配。

首先，我们编写了一个简单的程序，创建了多个子进程，并通过进程标识符（PID）来跟踪它们的运行状态。

然后，使用等待函数来等待子进程的结束，并获取其返回值。

在实验过程中，我们发现进程的创建和销毁需要消耗一定的系统资源，而且进程之间的同步和通信需要谨慎处理，以避免出现死锁和竞争条件等问题。

2、内存管理实验内存管理是操作系统的核心功能之一，它直接影响系统的性能和稳定性。

在这个实验中，我们研究了动态内存分配和释放的机制。

使用 C+＋中的 new 和 delete 操作符来分配和释放内存。

通过观察内存使用情况和内存泄漏检测工具，了解了内存分配的效率和可能出现的内存泄漏问题。

同时，我们还探讨了内存分页和分段的概念，以及虚拟内存的工作原理。

通过模拟内存访问过程，理解了页表的作用和地址转换的过程。

3、文件系统实验文件系统是操作系统用于管理文件和目录的机制。

在这个实验中，我们对文件的创建、读写和删除进行了操作。

使用 C+＋的文件流操作来实现对文件的读写。

通过创建不同类型的文件（文本文件和二进制文件），并对其进行读写操作，熟悉了文件的打开模式和读写方式。

此外，还研究了文件的权限设置和目录的管理，了解了如何保护文件的安全性和组织文件的结构。

4、设备管理实验设备管理是操作系统与外部设备进行交互的桥梁。

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

操作系统文件管理系统模拟实验在计算机科学中，操作系统是一种系统软件，负责管理计算机硬件和软件资源，并为用户和应用程序提供接口。

文件管理系统是操作系统的一个重要组成部分，它负责管理计算机系统中的文件和目录，以及提供对它们的访问和操作。

本次实验旨在模拟操作系统中文件管理系统的基本功能和操作。

我们将使用一个虚拟的文件系统，通过命令行界面来模拟用户与文件系统的交互。

以下是实验的具体内容和步骤：1. 创建虚拟文件系统首先，我们需要创建一个虚拟的文件系统。

文件系统由文件和目录组成，可以通过树状结构来表示。

我们可以使用一个数据结构来模拟文件系统的存储和管理。

2. 初始化文件系统在开始操作文件系统之前，我们需要初始化文件系统。

3. 文件和目录的创建与删除文件和目录是文件系统的基本单位。

我们可以通过命令来创建和删除文件和目录。

例如，使用"mkdir"命令创建一个目录，使用"touch"命令创建一个空文件，使用"rm"命令删除文件或目录。

4. 文件和目录的访问权限文件和目录可以设置不同的访问权限，以保护文件系统的安全性。

我们可以使用"chmod"命令来修改文件或目录的权限。

权限通常包括读、写和执行权限。

5. 文件和目录的重命名和移动我们可以使用"mv"命令来重命名文件或目录，使用"cp"命令来复制文件或目录，使用"mv"命令来移动文件或目录。

6. 文件和目录的查找和显示我们可以使用"ls"命令来显示当前目录下的文件和目录，使用"cd"命令来切换当前目录，使用"pwd"命令来显示当前目录的路径。

此外，我们还可以使用"find"命令来查找文件或目录。

7. 文件和目录的读写操作文件可以被读取和写入。

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

操作系统文件管理系统模拟实验操作系统文件管理系统模拟实验一、实验目的本实验旨在通过模拟操作系统的文件管理系统，加深对操作系统文件管理的理解，锻炼操作系统的应用能力。

二、实验环境1、操作系统：Windows/Linux/MacOS2、编程语言：C/C++/Java/Python等三、实验内容1、初始化文件管理系统1.1 创建根目录，并初始化空文件目录1.2 初始化用户目录和权限设置2、文件操作2.1 创建文件2.1.1 检查文件名合法性2.1.2 检查文件是否已存在2.1.3 为新文件分配磁盘空间2.1.4 添加文件元数据信息2.2 打开文件2.2.1 检查文件是否存在2.2.2 检查用户权限2.3 读取文件内容2.3.1 读取文件权限检查2.3.2 读取文件内容2.4 写入文件内容2.4.1 写入文件权限检查2.4.2 写入文件内容2.5 删除文件2.5.1 检查文件是否存在2.5.2 检查用户权限2.5.3 释放文件占用的磁盘空间2.5.4 删除文件元数据信息3、目录操作3.1 创建子目录3.1.1 检查目录名合法性3.1.2 检查目录是否已存在3.1.3 添加目录元数据信息3.2 打开目录3.2.1 检查目录是否存在3.2.2 检查用户权限3.3 列出目录内容3.3.1 列出目录权限检查3.3.2 列出目录内容3.4 删除目录3.4.1 检查目录是否存在3.4.2 检查用户权限3.4.3 递归删除目录下所有文件和子目录3.4.4 删除目录元数据信息四、实验步骤1、根据实验环境的要求配置操作系统和编程语言环境。

2、初始化文件管理系统，创建根目录，并初始化用户目录和权限设置。

3、进行文件操作和目录操作。

五、实验结果分析根据实验步骤进行文件操作和目录操作，观察系统的运行情况并记录相关实验结果。

六、实验结论通过本实验，深入了解了操作系统中文件管理系统的相关原理和实现方式，并且通过实验操作进一步巩固了相应的应用能力。

简单文件系统模拟实验

简单文件系统模拟实验实验目的通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统功能和实现过程的理解。

实验内容▪在内存中开辟一个虚拟磁盘空间作为文件存储器，在其上实现一个简单的单用户文件系统。

在退出这个简单文件系统时，应将该虚拟文件系统保存到磁盘上，以便下次可以再将它恢复到内存的虚拟磁盘上。

▪文件存储空间的分配可以采用显式链接分配或其它方法。

▪空闲空间的管理可以选择位示图或其它方法。

如果采用位示图来管理文件存储空间，并采用显式链接分配方式，可以将位示图合并到FAT中。

为简单起见，可以不使用索引结点，其中的每个目录项包含文件名、物理地址、文件长度等信息，还可以通过目录项实现对文件读和写的保护。

▪要求提供以下有关的文件操作：✧Format：对文件存储器进行格式化，即按照文件系统的结构对虚拟磁盘空间进行布局，并在其上创建根目录以及用于管理文件存储空间等的数据结构。

✧Mkdir：用于创建子目录。

✧Rmdir：用于删除子目录。

✧Ls：用于显示目录。

✧Cd：用于更改当前目录。

✧Create：用于创建文件。

✧Open：用于打开文件。

✧Close：用于关闭文件。

✧Write：用于写文件。

✧Read：用于读文件。

✧Rm：用于删除文件。

数据结构设计磁盘：整个磁盘为一个char数组，数组中的每一个元素当做是一个扇区，每个扇区可以存储1个字节的信息，簇大小为8字节。

FAT表：存储的是指定编号的簇的下一个簇的编号是什么，因为文件是有可能分散在很多的簇里。

文件和文件夹链表：设计为静态链表，每个文件夹都会有一个子目录列表，存在链表中。

文件和目录表：文件和目录相同对待，信息存放在文件目录表中，为一个数组类型。

以上所有的信息存放在一个fs结构体中，所有的结构都为静态实现，所以需要将文件系统存放到磁盘中的时候只需要将整个结构体以二进制性质存放到文件中或者是将从文件中以二进制形式读取。

操作系统文件管理实验报告

操作系统文件管理实验报告操作系统文件管理实验报告1：引言本实验报告旨在详细描述操作系统文件管理实验的设计、实施和结果。

文件管理是操作系统的重要组成部分，负责对计算机中的文件进行组织、存储和访问。

本实验通过模拟文件管理的过程，加深对文件管理的理解和实践。

2：实验目的本实验的主要目的是：- 理解文件系统的概念和原理- 掌握文件的创建、读取、写入和删除等基本操作- 实施并测试文件的分配和回收算法- 评估不同的文件分配算法对系统性能的影响3：实验环境本实验的实施环境如下：- 操作系统：Windows 10- 开发环境：C++ 编程语言4：实验内容4.1 文件系统设计在文件系统设计中，首先确定文件的基本单位，例如块或扇区。

然后，定义文件控制块（FCB）结构，用于存储文件的元数据信息，如文件名、大小、创建时间、权限等。

接下来，设计文件分配表，记录系统中每个块的使用情况，用于实现文件的分配和回收。

4.2 文件的创建和删除在文件的创建过程中，首先为文件分配空间，并更新文件分配表。

然后，创建文件的FCB，并将其到目录项中。

在文件的删除过程中，首先释放文件的空间，并更新文件分配表。

然后，删除文件的FCB，并从目录项中移除。

4.3 文件的读写操作文件的读写操作是用户对文件进行读取和修改的过程。

在文件读取操作中，首先找到要读取的文件的FCB，获取文件的起始块地址，并从起始块中读取数据。

在文件写入操作中，首先找到要写入的文件的FCB，获取文件的起始块地址，并将数据写入起始块。

若文件大小超过起始块的容量，则按照一定的分配算法继续分配空间。

4.4 文件分配算法文件分配算法决定了操作系统如何管理文件的空间分配。

常用的文件分配算法包括顺序分配、分配和索引分配。

顺序分配将文件连续地存储在磁盘上，易于实现但可能产生外部碎片。

分配使用链表结构将文件存储在磁盘的不连续块中，不易产生外部碎片但可能引起存取时间增长。

索引分配使用索引表将文件存储在磁盘的不连续块中，不易产生外部碎片且存取时间相对较短，但索引表本身需要占用存储空间。

操作系统设计一个二级文件系统报告

v .. . ..
. . . 资料. .
操作系统(2014年秋季学期)
实验报告
系别：计算机科学与技术班级：信安12-1班姓名：*** 学号：
实验名称：进程调度
NORTH CHINA UNIVERSITY OF TECHNOLOGY
2022-4-26 2/17
.
Word 资料
NORTH CHINA UNIVERSITY OF TECHNOLOGY
2022-4-26 4/17
.
Word 资料
NORTH CHINA UNIVERSITY OF TECHNOLOGY
.
Word 资料
NORTH CHINA UNIVERSITY OF TECHNOLOGY
.
Word 资料
NORTH CHINA UNIVERSITY OF TECHNOLOGY
}
五、编译过程截图
（下面是一个例子，换上你自己的图）
六、测试用例
（下面是一个例子，换上你自己的）
文字叙述一下测试过程的实例。

如先创建用户***、再产生文件****、再打开文件****，再写入内容********，再退出，再打开用户***，再将文件读出，读出的内容应该是*******。

等等。

六、实验结果
（下面是一个例子，换上你自己的图，给出根据测试用例的截图）。

实验4 文件系统模拟

实验4 文件系统模拟一、实验目的：设计和实现基于FAT12的模拟磁盘卷及其I/O系统的文件存取操作基本功能函数，深入领会和理解文件系统的体系结构、工作原理和设计要领。

二、实验设计1.根据FAT12设计模拟磁盘（1.44MB软盘映像文件）的磁盘组织结构及文件或空闲盘块管理方法与描述用数据结构，并实现模拟磁盘的创建和格式化操作。

2.设计和实现模拟磁盘I/O操作暨物理盘块与缓冲区（缓冲区与物理盘块大小相同）间数据交互的两个函数。

3.构建和提供用户与文件系统之间的基本接口，包括目录和文件的创建、重命名、删除和显示操作，目录的进入操作以及文件的定位及读、写操作。

4.测试系统功能并给出有效证据。

三、源程序清单和说明#include <stdio.h>#include <string.h>#include <stdlib.h>#define BlockSize 512#define DirSize 32#define RootSize 2struct ReserveBlock{int sysblocknum;/*文件系统总扇区数*/int resblocknum;/*保留扇区扇区数*/int fatblocknum;/*FA T表扇区数*/int rootblocknum;/*根目录区扇区数*/char fillchar[BlockSize-4*sizeof(int)];/*填充字节*/};struct DirBlock{char filename[11]; /*文件名限长11个字符*/charfillchar[DirSize-4*sizeof(int)-sizeof(long int)-11];/*填充字节*/long filelen; /*文件长度*/int year,month,day; /*日期*/int firstblockaddr; /*文件首块扇区号*/};struct FCBBlock{int fileid; /*文件标识*/struct DirBlock fileinfo; /*目录信息*/long filepos; /*文件读写指针*/int fdtblockaddr; /*目录项所在块号*/int fdtblockindex; /*目录项所在块内序号*/struct FCBBlock *next;/*指向下一个文件控制块的指针*/};struct ReserveBlock sys1;struct FCBBlock *fcb;struct DirBlock fil[32],*dir;/*目录项*/ int *fat1;char *str,*ptr;char fillchar[BlockSize];FILE *fp;FILE *OPENSYS(char *filename){int i;fp=fopen(filename,"rb+");fread(&sys1,1,BlockSize,fp);fat1=(int *)malloc(sys1.sysblocknum);for(i=0;i<sys1.fatblocknum;i++)fread(fat1,sizeof(int)*sys1.sysblocknum,1,fp); /*把基本的文件系统都读进来*/fseek(fp,(sys1.fatblocknum+sys1.resblocknum )*BlockSize,0);/*修改文件指针的位置*/ dir=fil;/*目录指针*/fread(dir,DirSize*32,1,fp);return fp;}int CLOSESYS(FILE *stream){int i;fseek(stream,sys1.resblocknum*BlockSize,0);fwrite(fat1,sizeof(int)*sys1.sysblocknum,1,str eam);fseek(fp,(sys1.fatblocknum+sys1.resblocknum )*BlockSize,0);fwrite(dir,DirSize*32,1,fp);fclose(fp);return 1;}int FCREA TE(char *filename)/*建立文件*/ {int i,flag=0,j,k=0,flag1=0,flag2=0,a;int n,m;while(1){a=strlen(filename);/*文件名长度*/if(a>10){printf("文件名过长\n");printf("请重新输入:");scanf("%s",filename);}elsebreak;}while(1){for(i=0;i<32;i++)if(strcmp(filename,fil[i].filename)==0){printf("该文件名已存在\n");printf("请重新输入:");flag1=1;break;}if(flag1==0)break;scanf("%s",filename);flag1=0;}for(i=(sys1.fatblocknum+sys1.resblocknum+s ys1.rootblocknum);i<sys1.sysblocknum;i++) if(fat1[i]==0)flag++;/*统计磁盘上为空数目*/if(flag==0){ printf("磁盘已满");/*统计结果为0,则磁盘已满*/return 0;}printf("空闲块数:%d\n",flag);printf("请输入文件长度:");for(j=0;j<32;j++)if(fil[j].firstblockaddr==0)break;while(1){scanf("%d",&dir[j].filelen);/*输入目录项中文件的长度*/n=(dir[j].filelen/BlockSize)+(dir[j].filelen%Bl ockSize?1:0);if(n<0||n>flag)/*文件长度小于0或大于空闲的空间*/{printf("文件长度过长\n");printf("请重新输入:");}elsebreak;}for(i=(sys1.fatblocknum+sys1.resblocknum+s ys1.rootblocknum);i<sys1.sysblocknum;i++)/ *文件内容区域*/{ if(fat1[i]==0){k++;if(flag2==0){ dir[j].firstblockaddr=i+1;flag2=1;}else{ if(k>=n)/*n 文件长度*/{ fat1[m]=i+1;fat1[i]=-1;break;}elsefat1[m]=i+1;}m=i;}}strcpy(dir[j].filename,filename);dir[j].filename[a]='\0';printf("请输入年份:");scanf("%d",&dir[j].year);printf("请输入月份:");scanf("%d",&dir[j].month);printf("请输入日期:");scanf("%d",&dir[j].day);return (1);}void LISTDIR(void)/*显示目录*/{int i,flag=0;for(i=0;i<32;i++){if(fil[i].firstblockaddr!=0){if(flag==0)printf("filename \n");flag=1; /*标示*/printf("%s\n",fil[i].filename);}}}int FDELETE(char *filename)/*删除文件*/ {int i,j,k,n,flag=0;struct FCBBlock *p;/*文件控制块指针*/p=fcb;while(p){if(strcmp(filename,fil[p->fdtblockindex].filen ame)==0)/*目录项所在内序号*/{printf("文件已经打开，请先关闭文件\n");return 0;}elsep=p->next;}for(i=0;i<32;i++)/*查找要关闭的文件*/if(strcmp(filename,fil[i].filename)==0){ flag=1;break;}if(flag==0){printf("文件不存在\n");return 0;}j=fil[i].firstblockaddr;while(1){k=fat1[j-1];fseek(fp,(j-1)*BlockSize,0);/*将指针指向文件的第一个扇区的位置*/fwrite(&fillchar,1,BlockSize,fp);fat1[j-1]=0;if(k==-1)break;elsej=k;}memset(&fil[i],0,DirSize);return 1;}int FOPEN(char *filename)/*打开文件*/ {int i,j=0,k,flag=0;struct FCBBlock *p,*q,*r;p=fcb;for(i=0;i<32;i++)if(strcmp(filename,fil[i].filename)==0)/*找到要打开的文件*/{ flag=1;break;}if(flag==0){printf("文件不存在\n");return 0;}while(p){j++;if(strcmp(filename,fil[p->fdtblockindex].filen ame)==0){printf("文件已打开\n");return 0;}q=p;p=p->next;}if(fcb==NULL){ fcb=(struct FCBBlock *)malloc(sizeof(struct FCBBlock));fcb->fileid=j+1;/*文件标示*/fcb->filepos=0;/*文件读写指针*/fcb->next=NULL;/*指向下一个文件控制指针*/fcb->fdtblockindex=i;}else{ r=(struct FCBBlock *)malloc(sizeof(struct FCBBlock));r->fileid=j+1;r->filepos=0;r->next=NULL;r->fdtblockindex=i;q->next=r;}/*f->next=NULL; */return 1;}long FGETLEN(int fileid)/*获取文件指针*/ { struct FCBBlock *p;p=fcb;while(p){if(p->fileid==fileid)/*寻找要找的指针*/return(p->filepos);p=p->next;}printf("error\n");return(0);}int FCLOSE(char *filename)/*关闭文件*/ { int flag=0;struct FCBBlock *f,*p;f=fcb;if(strcmp(filename,fil[fcb->fdtblockindex].file name)==0){ flag=1;fcb=fcb->next;p=fcb;while(p){p->fileid-=1;p=p->next;}return flag;}p=f;f=f->next;while(f){if(strcmp(filename,fil[f->fdtblockindex].filena me)==0){ flag=1;p=f->next;/*p=p->next;*/while(p){ p=p->next;p->fileid-=1;}free(f);return flag;}p=f;f=f->next;}if(flag==0){ printf("文件未打开\n'");return flag;}return 0;}int FREAD(char *str, int n, int fileid)/*文件块读*/{ int m,i,j=0,k,l,len;char a[3];struct FCBBlock *p;p=fcb;while(p){if(p->fileid==fileid)break;elsep=p->next;}len=fil[p->fdtblockindex].filelen;/*文件长度*/l=p->filepos;/*文件读写指针:该块在文件的相对位置*/printf("现在打开文件:");printf("%d\n",l);printf("是否读入这个文件?(Y/N):");scanf("%s",a);if(a[0]=='n'||a[0]=='N'){printf("输入内容:");while(1){scanf("%d",&l);if(fil[p->fdtblockindex].filelen<(l+n))/*？*/printf("too large!\ninput again:");elsebreak;}}while(1){if(n>fil[p->fdtblockindex].filelen){printf("too large!\n");printf("input read size,again:");scanf("%d",&n);}elsebreak;}str=(char*)malloc(fil[p->fdtblockindex].filelen+1);m=(len/BlockSize)+(len%BlockSize?1:0);k=fil[p->fdtblockindex].firstblockaddr;if(m>1){ fseek(fp,(k-1)*BlockSize,0);fread(str,BlockSize,1,fp);k=fat1[k-1];for(i=1;i<(m-1);i++){fseek(fp,fat1[k-1]*BlockSize,0);fread(&str[i*BlockSize],BlockSize,1,fp);k=fat1[k-1];}fseek(fp,(k-1)*BlockSize,0);fread(&str[i*BlockSize],len-i*BlockSize,1,fp);}else{ fseek(fp,(k-1)*BlockSize,0);fread(str,len,1,fp);}str[n+l]='\0';if(l!=0)str=&str[l];p->filepos=n+l;printf("%s\n",str);return 1;}void FWRITE(char *ptr, int n, int fileid){ char a[3];long l;int m,i=0,j,k=0,num,flag=0,flag1=0,b;struct FCBBlock *p;p=fcb;while(p){if(p->fileid==fileid)break;elsep=p->next;}l=p->filepos;printf("现在打开文件:");printf("%d\n",l);printf("是否写入这个文件?(Y/N):");scanf("%s",a);if(a[0]=='n'||a[0]=='N'){printf("输入内容:");while(1){scanf("%d",&l);if(fil[p->fdtblockindex].filelen<(l+n))printf("too large!\ninput again:");elsebreak;}}j=(l/BlockSize)+(l%BlockSize?1:0);if(l==0)j=1;num=fil[p->fdtblockindex].firstblockaddr;for(i=1;i<j;i++)num=fat1[num];do{if(flag==0){fseek(fp,(num-1)*BlockSize+l-(i-1)*BlockSi ze,0);flag=1;}else{fseek(fp,(num-1)*BlockSize,0);num=fat1[num-1];}if(((n+l)-(i-1)*BlockSize)>BlockSize ){if(flag1==0){fwrite(&ptr[0],j*BlockSize-l,1,fp);flag1=1;}else{fwrite(&ptr[j*BlockSize-l+k*BlockSize],Blo ckSize,1,fp);}}else{ m=j*BlockSize-l+(k-1)*BlockSize;b=n-(j*BlockSize-l+(k-1)*BlockSize);fwrite(&ptr[m],b,1,fp);}k++;i++;}while(((n+l)-(i-1)*BlockSize)>1);p->filepos=l+n;}int FEOF(int fileid){int flag;struct FCBBlock *p;p=fcb;while(p){if(p->fileid==fileid)break;}if(p->filepos>fil[p->fdtblockindex].filelen)return 0;elsereturn 1;}long FGETPOS(int fileid){struct FCBBlock *p;p=fcb;while(p){if(p->fileid==fileid)return (p->filepos);elsep=p->next;}printf("error!\n");return(0);}int FSETPOS(int fileid, long offset){struct FCBBlock *p;p=fcb;while(p){ if(p->fileid==fileid){ while(offset>fil[p->fdtblockindex].filelen||of fset<0){printf("set error!zhe pos >file length\n");printf("input file pos ,again:");scanf("%d",offset);}p->filepos=offset;return 1;}elsep=p->next;}printf("error!\n");return(0);}void DISPLAY(){printf("请输入命令:\n");printf("建立文件:creat\n");printf("显示目录:list\n");printf("删除文件:del\n");printf("打开文件:open\n");printf("关闭文件:close\n");printf("文件块读:read\n");printf("文件块写:write\n");printf("退出:exit\n");}void test(char *filename){char *t,cmd[10],fname[12];struct FCBBlock *p;int i,j,n,flag,len,id,flag1=0;fp=OPENSYS(filename);while(1){DISPLAY();scanf("%s",cmd);if(!strcmp(cmd,"creat")){printf("请输入文件名：\n");scanf("%s",fname);flag=FCREA TE(fname);if(flag==1)printf("文件%s 创建成功\n",fname);}else if(!strcmp(cmd,"list"))LISTDIR();else if(!strcmp(cmd,"del")){scanf("%s",fname);flag=FDELETE(fname);if(flag==1)printf("文件%s 删除成功\n",fname);}else if(!strcmp(cmd,"open")){scanf("%s",fname);flag=FOPEN(fname);if(flag==1)printf("文件%s 打开\n",fname);}else if(!strcmp(cmd,"close")){scanf("%s",fname);flag=FCLOSE(fname);if(flag==1)printf("文件%s 关闭\n",fname);}else if(!strcmp(cmd,"read")){scanf("%s",fname);p=fcb;flag1=0;while(p){ if(!strcmp(fil[p->fdtblockindex].filename,fn ame)){printf("请输入文件大小:");scanf("%d",&len);id=p->fileid;flag=FREAD(str,len,id);flag1=1;}p=p->next;}if(flag1==0)printf("文件%s 未打开，请先打开文件\n",fname);}else if(!strcmp(cmd,"write")){scanf("%s",fname);p=fcb;flag1=0;while(p){ if(!strcmp(fil[p->fdtblockindex].filename,fn ame)){printf("请输入文件大小:");do{scanf("%d",&len);if(len>fil[p->fdtblockindex].filelen)printf("文件长度过大，请重新输入：");}while(len>fil[p->fdtblockindex].fil elen);id=p->fileid;ptr=(char *)malloc(len);scanf("%s",ptr);FWRITE(ptr,len,id);flag1=1;}p=p->next;}if(flag1==0)printf("文件%s 未打开，请先打开文件\n",fname);}else if(!strcmp(cmd,"exit")){flag=CLOSESYS(fp);break;}elseprintf("error!\n");}}int main(void){ struct ReserveBlock sys;char filename[]="fatsys.dat";int *fat;int i,j;fcb=NULL;memset(&sys,255,BlockSize);printf("请输入索要创建的文件系统的大小(5~32767):");scanf("%d",&(sys.sysblocknum));sys.resblocknum=1;sys.fatblocknum=sys.sysblocknum/(BlockSize /sizeof(int))+((sys.sysblocknum%(BlockSize/sizeof(int)))?1 :0);fat=(int*)malloc(BlockSize*sys.fatblocknum);memset(fat,255,BlockSize*sys.fatblocknum);memset(fat,0,sizeof(int)*sys.sysblocknum);sys.rootblocknum=RootSize;j=sys.resblocknum+sys.fatblocknum+sys.root blocknum;for (i=0;i<j;i++)fat[i]=-1;memset(&fillchar,0,BlockSize);fp=fopen(filename,"w+b");fwrite(&sys,1,BlockSize,fp);for (i=0;i<sys.fatblocknum;i++)fwrite(fat+i*BlockSize/sizeof(int),1,BlockSize ,fp);j=sys.resblocknum+sys.fatblocknum;for(i=0;i<(sys.sysblocknum-j);i++)fwrite(&fillchar,1,BlockSize,fp);fclose(fp);free(fat);test(filename);return 0;}四、算法及关键数据结构设计1.模拟磁盘的格式化操作2.磁盘I/O操作模拟函数readBlock(int i, char *p);该函数把i#逻辑块的内容读入到指针p指向的盘块缓冲（注意读入计数处理）。

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

文件管理系统模拟1.实验目的通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现2.实验内容为Linux系统设计一个简单的二级文件系统。

要求做到以下几点：（1）可以实现下列几条命令（至少4条）login 用户登录dir 列文件目录create 创建文件delete 删除文件open 打开文件close 关闭文件read 读文件write 写文件（2）列目录时要列出文件名、物理地址、保护码和文件长度；（3）源文件可以进行读写保护。

3.实验提示（1）首先应确定文件系统的数据结构：主目录、子目录及活动文件等。

主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。

（2）用户创建的文件，可以编号存储于磁盘上。

入file0,file1,file2…并以编号作为物理地址，在目录中进行登记。

4.源代码#include<stdio.h>#include<string.h>#include<stdlib.h>#define MEM_D_SIZE 1024*1024 //总磁盘空间为1M#define DISKSIZE 1024//磁盘块的大小1K#define DISK_NUM 1024//磁盘块数目1K#define FATSIZE DISK_NUM*sizeof(struct fatitem)//FAT表大小#define ROOT_DISK_NO FATSIZE/DISKSIZE+1//根目录起始盘块号#define ROOT_DISK_SIZE sizeof(struct direct) //根目录大小#define DIR_MAXSIZE 1024//路径最大长度为1KB#define MSD 5//最大子目录数5#define MOFN 5//最大文件深度为5#define MAX_WRITE 1024*128//最大写入文字长度128KBstruct fatitem /* size 8*/{int item; /*存放文件下一个磁盘的指针*/char em_disk; /*磁盘块是否空闲标志位 0 空闲*/};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];};struct opentable{struct openttableitem{char name[9]; /*文件名*/int firstdisk; /*起始盘块号*/int size; /*文件的大小*/ }openitem[MOFN];int cur_size; /*当前打文件的数目*/};struct fatitem *fat; /*FAT表*/ struct direct *root; /*根目录*/ struct direct *cur_dir; /*当前目录*/struct opentable u_opentable; /*文件打开表*/int fd=-1; /*文件打开表的序号*/char *bufferdir; /*记录当前路径的名称*/char *fdisk; /*虚拟磁盘起始地址*/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();void initfile(){fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char) ); /*申请 1M空间*/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<ROOT_DISK_NO-1;i++) /*存放 FAT表的磁盘块号*/{fat[i].item=i+1;fat[i].em_disk='1';}fat[ROOT_DISK_NO].item=-1;/*存放根目录的磁盘块号*/fat[ROOT_DISK_NO].em_disk='1' ;for(i=ROOT_DISK_NO+1;i<DISK_N UM;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].na me,".");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].na me,"..");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<MSD+2;i++) /*-子目录初始化为空-*/{root->directitem[i].sign = 0;root->directitem[i].firstdisk = -1;strcpy(root->directitem[i].na me,"");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); } 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<MOFN;i++) { strcpy(u_opentable.openitem[i ].name,""); u_opentable.openitem[i].first disk = -1; u_opentable.openitem[i].size = 0; } u_opentable.cur_size = 0; cur_dir = root; /*当前目录为根目录*/ bufferdir = (char *)malloc(DIR_MAXSIZE*sizeof(char )); strcpy(bufferdir,"Root:"); } 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;}int create(char *name){int i,j;if(strlen(name)>8) /*文件名大于 8位*/return(-1);for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/ {if(!strcmp(cur_dir->directite m[j].name,name))break;}if(j<MSD+2) /*文件已经存在*/return(-4);for(i=2;i<MSD+2;i++) /*找到第一个空闲子目录*/{if(cur_dir->directitem[i].fir stdisk==-1)break;}if(i>=MSD+2) /*无空目录项*/ return(-2); if(u_opentable.cur_size>=MOFN) /*打开文件太多*/return(-3);for(j=ROOT_DISK_NO+1;j<DISK_NUM; j++) /*找到空闲盘块 j 后退出*/ {if(fat[j].em_disk=='0')break;}if(j>=DISK_NUM)return(-5);fat[j].em_disk = '1'; /*将空闲块置为已经分配*//*-----------填写目录项-----------------*/strcpy(cur_dir->directitem[i].na me,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;}int open(char *name){int i, j;for(i=2;i<MSD+2;i++) /*文件是否存在*/ { if(!strcmp(cur_dir->directite m[i].name,name)) break; } if(i>=MSD+2) return(-1); /*--------是文件还是目录-----------------------*/ if(cur_dir->directitem[i].pro perty=='1') return(-4); /*--------文件是否打开-----------------------*/ for(j=0;j<MOFN;j++) { if(!strcmp(u_opentable.openit em[j].name,name)) break; } if(j<MOFN) /*文件已经打开*/ return(-2); if(u_opentable.cur_size>=MOFN) /*文件打开太多*/ return(-3); /*--------查找一个空闲用户打开表项-----------------------*/ for(j=0;j<MOFN;j++) { if(u_opentable.openitem[j].fi rstdisk==-1) break; } /*--------------填写表项的相关信息------------------------*/ u_opentable.openitem[j].firstdis k = cur_dir->directitem[i].firstdisk ; strcpy(u_opentable.openitem[j].n ame,name); u_opentable.openitem[j].size = cur_dir->directitem[i].size; u_opentable.cur_size++; /*----------返回用户打开表表项的序号--------------------------*/ return(j); } int close(char *name) { int i; for(i=0;i<MOFN;i++) {if(!strcmp(u_opentable.openit em[i].name,name)) break; } if(i>=MOFN) return(-1); /*-----------清空该文件的用户打开表项的内容---------------------*/ strcpy(u_opentable.openitem[i].n ame,""); u_opentable.openitem[i].firstdis k = -1; u_opentable.openitem[i].size = 0; u_opentable.cur_size--;return 0;}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<len;i++){if(buf[i] == '$')buf[i] = Space;else if(buf[i] == '#')buf[i] = Endter;}/*----------读取用户打开表对应表项第一个盘块号-----------------------*/item = u_opentable.openitem[fd].firstdi sk;/*-------------找到当前目录所对应表项的序号-------------------------*/for(i=2;i<MSD+2;i++){if(cur_dir->directitem[i].fir stdisk==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.openi tem[fd].size%DISKSIZE>len){strcpy(first,buf);u_opentable.openitem[fd].size =u_opentable.openitem[fd].size+le n;cur_dir->directitem[temp].siz e = cur_dir->directitem[temp].size+l en;}else{for(i=0;i<(DISKSIZE-u_opentab le.openitem[fd].size%DISKSIZE);i ++){/*写一部分内容到最后一块磁盘块的剩余空间(字节)*/first[i] = buf [i];}/*-----计算分配完最后一块磁盘的剩余空间(字节) 还剩下多少字节未存储-------*/ilen1 = len-(DISKSIZE-u_opentable.openit em[fd].size%DISKSIZE);ilen2 = ilen1/DISKSIZE;modlen = ilen1%DISKSIZE;if(modlen>0)ilen2 = ilen2+1; /*--还需要多少块磁盘块-*/for(j=0;j<ilen2;j++){for(i=ROOT_DISK_NO+1;i<DISK_N UM;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<len-(DISKSIZE-u_ope ntable.openitem[fd].size%DISKSIZ E)-j*DISKSIZE;k++)first[k] = buf[k];}else/*-如果不是要最后分配的一块--*/{for(k=0;k<DISKSIZE;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+le n;cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+l en;}return 0;}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].firstdi sk;ilen1 = len/DISKSIZE;modlen = len%DISKSIZE;if(modlen!=0)ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/first = fdisk+item*DISKSIZE; /*--计算文件的起始位置-*/for(i=0;i<ilen1;i++){if(i==ilen1-1) /*--如果在最后一个磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];}else /*--不在最后一块磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];item = fat[item].item; /*-查找下一盘块-*/first = fdisk+item*DISKSIZE;}}return 0;}int del(char *name){int i,cur_item,item,temp;for(i=2;i<MSD+2;i++) /*--查找要删除文件是否在当前目录中-*/ {if(!strcmp(cur_dir->directite m[i].name,name))break;}cur_item = i; /*--用来保存目录项的序号,供释放目录中-*/ if(i>=MSD+2) /*--如果不在当前目录中-*/return(-1);if(cur_dir->directitem[cur_it em].property!='0') /*--如果删除的(不)是目录-*/return(-3);for(i=0;i<MOFN;i++) /*--如果文件打开,则不能删除,退出-*/ {if(!strcmp(u_opentable.openit em[i].name,name))return(-2);}item = cur_dir->directitem[cur_item].fi rstdisk;/*--该文件的起始盘块号-*/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[c ur_item].name,"");cur_dir->directitem[cur_item].ne xt = -1;cur_dir->directitem[cur_item].pr operty = '0';cur_dir->directitem[cur_item].size = 0;return 0;}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<MSD+2;i++) /*-如果有空闲目录项退出-*/{if(cur_dir->directitem[i].fir stdisk==-1)break;}if(i>=MSD+2) /*-目录/文件已满-*/return(-2);for(j=2;j<MSD+2;j++) /*-判断是否有重名-*/{if(!strcmp(cur_dir->directite m[j].name,name))break;}if(j<MSD+2) /*-如果有重名-*/ return(-3);for(j=ROOT_DISK_NO+1;j<DISK_N UM;j++) /*-找到空闲磁盘块 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].firstd isk=j;cur_dir->directitem[i].size=R OOT_DISK_SIZE;cur_dir->directitem[i].next=j ;cur_dir->directitem[i].proper ty='1';/*-所创目录在虚拟磁盘上的地址(内存物理地址)-*/cur_mkdir=(struct direct *)(fdisk+cur_dir->directitem[i]. firstdisk*DISKSIZE);/*-初始化目录-*//*-指向当前目录的目录项-*/cur_mkdir->directitem[0].sign =0;cur_mkdir->directitem[0].firs tdisk=cur_dir->directitem[i].fir stdisk;strcpy(cur_mkdir->directitem[ 0].name,".");cur_mkdir->directitem[0].next =cur_mkdir->directitem[0].firstd isk;cur_mkdir->directitem[0].prop erty='1';cur_mkdir->directitem[0].size =ROOT_DISK_SIZE;/*-指向上一级目录的目录项-*/cur_mkdir->directitem[1].sign =cur_dir->directitem[0].sign;cur_mkdir->directitem[1].firs tdisk=cur_dir->directitem[0].fir stdisk;strcpy(cur_mkdir->directitem[ 1].name,"..");cur_mkdir->directitem[1].next =cur_mkdir->directitem[1].firstd isk;cur_mkdir->directitem[1].prop erty='1';cur_mkdir->directitem[1].size =ROOT_DISK_SIZE;for(i=2;i<MSD+2;i++) /*-子目录都初始化为空-*/{cur_mkdir->directitem[i].sign =0;cur_mkdir->directitem[i].firs tdisk=-1;strcpy(cur_mkdir->directitem[ i].name,"");cur_mkdir->directitem[i].next =-1;cur_mkdir->directitem[i].prop erty='0';cur_mkdir->directitem[i].size =0;}return 0;}int rmdir(char *name){int i,j,item;struct direct *temp_dir;/*-检查当前目录项中有无该目录-*/for(i=2;i<MSD+2;i++){if(!strcmp(cur_dir->directite m[i].name,name))break;}if(i>=MSD+2) /*-没有这个文件或目录-*/return(-1);if(cur_dir->directitem[i].pro perty!='1')/*-删除的不是目录-*/ return(-3);/*-判断要删除的目录有无子目录-*/temp_dir=(struct direct *)(fdisk+cur_dir->directitem[i]. next*DISKSIZE);for(j=2;j<MSD+2;j++){if(temp_dir->directitem[j].ne xt!=-1)break;}if(j<MSD+2) /*-有子目录或文件-*/return(-2);/*------------找到起始盘块号,并将其释放----------------*/ item=cur_dir->directitem[i].f irstdisk;fat[item].em_disk='0';/*-修改目录项-*/cur_dir->directitem[i].sign=0 ;cur_dir->directitem[i].firstd isk=-1;strcpy(cur_dir->directitem[i] .name,"");cur_dir->directitem[i].next=-1;cur_dir->directitem[i].proper ty='0';cur_dir->directitem[i].size=0 ;return 0;}void dir(){int i;for(i=2;i<MSD+2;i++){if(cur_dir->directitem[i].fir stdisk!=-1) /*-如果存在子目录-*/ {printf("%s\t",cur_dir->direct item[i].name);if(cur_dir->directitem[i].pro perty=='0') /*-文件-*/printf("%d\t\t\n",cur_dir->di rectitem[i].size);elseprintf("\t<目录>\t\n");}}}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;}temp = (char *)malloc(DIR_MAXSIZE*sizeof(char ));/*-最长路径名字分配空间-*/for(i=0;i<(int)strlen(str);i+ +)temp[i]=str[i];temp[i]='\0';for(j=0;j<MSD+2;j++) /*-查找该子目录是否在当前目录中-*/ {if(!strcmp(temp_dir->directit em[j].name,temp))break;}free(temp);/*释放申请的临时空间*///if(temp_dir->directitem[j]. property!='1') /*-打开的不是目录-*///return(-2);if(j>=MSD+2) /*-不在当前目录-*/return(-1);item=temp_dir->directitem[j]. firstdisk;/*-当前目录在磁盘中位置-*/temp_dir=(struct direct *)(fdisk+item*DISKSIZE);if(!strcmp("..",name)){if(cur_dir->directitem[j-1].s ign!=1) /*-如果上级目录不是根目录-*/{point=strchr(bufferdir,'\\'); //查找字符串bufferdir中首次出现字符\ 的位置while(point!=NULL){point1=point+1; /*-减去'\'所占的空间,记录下次查找的起始地址-*/point=strchr(point1,'\\');}*(point1-1)='\0'; /*-将上一级目录删除-*/}}else{//if(name[0] !='\\')bufferdir = strcat(bufferdir,"\\"); /*-修改当前目录-*/bufferdir = strcat(bufferdir,name);}cur_dir=temp_dir; /*-将当前目录确定下来-*/return 0;}void show(){printf("%s>",bufferdir);} void print(){printf("********************* ******************************** ****\n");printf("********************* *文件系统设计***********************\n");printf("*\t命令格式说明*\n");printf("*\tcd 目录名更改当前目录*\n");printf("*\tmkdir 目录名创建子目录*\n");printf("*\trmdir 目录名删除子目录*\n");printf("*\tdir 显示当前目录的子目录*\n");printf("*\tcreate 文件名创建文件*\n");printf("*\tdel 文件名删除文件*\n");printf("*\topen 文件名打开文件*\n");printf("*\tclose 文件名关闭文件*\n");printf("*\tread 读文件*\n");printf("*\twrite 写文件*\n");printf("*\texit 退出系统*\n");printf("********************* ******************************** ****\n");}void main(){FILE *fp;char ch;char a[100];char code[11][10];char name[10];int i,flag,r_size;char *contect;contect = (char *)malloc(MAX_WRITE*sizeof(char));if((fp=fopen("disk.dat","rb"))==NULL){printf("You have not format,Do you want format?(y/n)");scanf("%c",&ch);if(ch=='y'){initfile();printf("Successfully format! \n");}else{return;}}enter();print();show();strcpy(code[0],"exit");strcpy(code[1],"create");strcpy(code[2],"open");strcpy(code[3],"close");strcpy(code[4],"write");strcpy(code[5],"read");strcpy(code[6],"del");strcpy(code[7],"mkdir");strcpy(code[8],"rmdir");strcpy(code[9],"dir");strcpy(code[10],"cd");while(1){scanf("%s",a);for(i=0;i<11;i++){if(!strcmp(code[i],a))break;}switch(i){case 0: //退出文件系统free(contect);halt();return;case 1: //创建文件scanf("%s",name);flag = create(name);if(flag==-1){printf("Error: \n The length is too long !\n");}else if(flag==-2){printf("Error: \n The direct item is already full !\n");}else if(flag==-3){printf("Error: \n The number of openfile is too much !\n");}else if(flag==-4){printf("Error: \n The name is already in the direct !\n");}else if(flag==-5){printf("Error: \n The disk space is full!\n");}else{printf("Successfully create a file! \n");}show();break;case 2://打开文件scanf("%s",name);fd = open(name);if(fd == -1){printf("Error: \n The open file not exit! \n");}else if(fd == -2){printf("Error: \n The file have already opened! \n");}else if(fd == -3){printf("Error: \n The number of open file is too much! \n");}else if(fd == -4){printf("Error: \n It is a direct,can not open for read or write! \n");}else{printf("Successfully opened! \n");}show();break;case 3://关闭文件scanf("%s",name);flag = close(name);if(flag == -1){printf("Error:\n The file is not opened ! \n");}else{printf("Successfully closed! \n");}show();break;case 4://写文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}else{printf("Please input the file contect:");scanf("%s",contect);flag=write(fd,contect,strlen( contect));if(flag == 0){printf("Successfully write! \n");}else{printf("Error:\n The disk size is not enough! \n");}}show();break;case 5://读文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}else{flag = read(fd,contect);if(flag == 0){for(i=0;i<u_opentable.openite m[fd].size;i++){printf("%c",contect[i]);}printf("\t\n");}}show();break;case 6://删除文件scanf("%s",name);flag = del(name);if(flag == -1){printf("Error:\n The file not exit! \n");}else if(flag == -2){printf("Error:\n The file is opened,please first close it ! \n");}else if(flag == -3){printf("Error:\n The delete is not file ! \n");}else{printf("Successfully delete! \n");}show();break;case 7://创建子目录scanf("%s",name);flag = mkdir(name);if(flag == -1){printf("Error:\n The length of name is to long! \n");}else if(flag == -2){printf("Error:\n The direct item is already full ! \n");}else if(flag == -3){printf("Error:\n The name is already in the direct ! \n");}else if(flag == -4){printf("Error: \n '..' or '.' can not as the name of the direct!\n");}else if(flag == -5){printf("Error: \n The disk space is full!\n");}else if(flag == 0){printf("Successfully make dircet! \n");}show();break;case 8://删除子目录scanf("%s",name);flag = rmdir(name);if(flag == -1){printf("Error:\n The direct is not exist! \n");}else if(flag == -2){printf("Error:\nThe direct has son direct ,please first remove the son dircct!\n");}else if(flag == -3){printf("Error:\n The remove is not direct ! \n");}else if(flag == 0){printf("Successfully remove dircet! \n");}show();break;case 9://显示当前子目录dir();show();break;case 10://更改当前目录scanf("%s",name);flag = cd(name);if(flag == -1){printf("Error:\n The path no correct!\n");}else if(flag == -2){printf("Error:\nThe opened is not direct!\n");}show();break;default:printf("\n Error!\n The command is wrong! \n");show();}}}5.程序运行截图6.实验总结通过这一次计算机操作系统的上机实验，使我对不同环境下的操作系统有了进一步的了解，使我学到了很多关于Linux的操作和相关知识。

《操作系统》课程实验报告

《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。

二、实验环境1、操作系统：Windows 10 专业版2、开发工具：Visual Studio Code3、编程语言：C/C+＋三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新进程，并观察进程的创建过程和资源分配情况。

同时，实现进程的正常终止和异常终止，并分析其对系统的影响。

2、进程同步与互斥使用信号量、互斥锁等机制实现进程之间的同步与互斥。

通过模拟多个进程对共享资源的访问，观察并解决可能出现的竞争条件和死锁问题。

（二）内存管理实验1、内存分配与回收实现不同的内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。

观察在不同的内存请求序列下，内存的分配和回收情况，并分析算法的性能和优缺点。

2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小、页表结构等参数，观察页面的换入换出过程，以及对系统性能的影响。

（三）文件系统实验1、文件操作实现文件的创建、打开、读取、写入、关闭等基本操作。

观察文件在磁盘上的存储方式和文件系统的目录结构。

2、文件系统性能优化研究文件系统的缓存机制、磁盘调度算法等，通过对大量文件的读写操作，评估不同优化策略对文件系统性能的提升效果。

四、实验步骤（一）进程管理实验步骤1、进程创建与终止（1）使用 C/C+＋语言编写程序，调用系统函数创建新进程。

（2）在子进程中执行特定的任务，父进程等待子进程结束，并获取子进程的返回值。

（3）通过设置异常情况，模拟子进程的异常终止，观察父进程的处理方式。

2、进程同步与互斥（1）定义共享资源和相关的信号量或互斥锁。

（2）创建多个进程，模拟对共享资源的并发访问。

（3）在访问共享资源的关键代码段使用同步机制，确保进程之间的正确协作。

（4）观察并分析在不同的并发情况下，系统的运行结果和资源竞争情况。

《操作系统》实验二

《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解，通过实际操作，提高对操作系统设计和实现的认知。

通过实验二，我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。

二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。

b.设计一个简单的进程调度算法，如轮转法或优先级调度法。

c.实现进程间的通信机制，如共享内存或消息队列。

2、线程调度a.实现线程的创建、撤销和调度。

b.实现一个简单的线程调度算法，如协同多任务（cooperative multitasking）。

3、内存管理a.设计一个简单的分页内存管理系统。

b.实现内存的分配和回收。

c.实现一个简单的内存保护机制。

4、文件系统a.设计一个简单的文件系统，包括文件的创建、读取、写入和删除。

b.实现文件的存储和检索。

c.实现文件的备份和恢复。

三、实验步骤1、进程管理a.首先，设计一个进程类，包含进程的基本属性（如进程ID、状态、优先级等）和操作方法（如创建、撤销、阻塞、唤醒等）。

b.然后，实现一个进程调度器，根据不同的调度算法对进程进行调度。

可以使用模拟的方法，不需要真实的硬件环境。

c.最后，实现进程间的通信机制，可以通过模拟共享内存或消息队列来实现。

2、线程调度a.首先，设计一个线程类，包含线程的基本属性（如线程ID、状态等）和操作方法（如创建、撤销等）。

b.然后，实现一个线程调度器，根据不同的调度算法对线程进行调度。

同样可以使用模拟的方法。

3、内存管理a.首先，设计一个内存页框类，包含页框的基本属性（如页框号、状态等）和操作方法（如分配、回收等）。

b.然后，实现一个内存管理器，根据不同的内存保护机制对内存进行保护。

可以使用模拟的方法。

4、文件系统a.首先，设计一个文件类，包含文件的基本属性（如文件名、大小等）和操作方法（如创建、读取、写入、删除等）。

b.然后，实现一个文件系统管理器，包括文件的存储和检索功能。

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

操作系统文件管理系统模拟实验近年来，随着计算机技术的飞速发展，操作系统的重要性日益凸显。

作为计算机的核心软件之一，操作系统负责管理计算机的硬件和软件资源，提供良好的用户界面和文件管理功能。

为了更好地理解和掌握操作系统的文件管理系统，我们进行了一次模拟实验。

实验的目的是通过模拟操作系统的文件管理系统，深入了解文件的创建、读取、写入、删除等操作。

我们使用了一台虚拟机作为实验平台，并在其上安装了一个基于Linux的操作系统。

虚拟机的使用使得我们能够在一个相对封闭的环境中进行实验，不会对真实的计算机系统造成任何影响。

在实验开始之前，我们对文件管理系统的基本概念进行了学习和了解。

文件管理系统是操作系统中的一个重要模块，负责对计算机中的文件进行管理和控制。

它包括了文件的创建、读写、删除等功能，并提供了对文件进行组织和访问的接口。

了解这些基本概念对于我们后续的实验非常重要。

在实验过程中，我们首先进行了文件的创建和读写操作。

通过使用命令行界面，我们成功地创建了一个新的文件，并向其中写入了一些内容。

接着，我们使用读取命令来读取文件的内容，并验证了文件的创建和读写操作的正确性。

这一步的实验让我们更加熟悉了文件的创建和读写过程，加深了对文件管理系统的理解。

接下来，我们进行了文件的删除操作。

通过使用删除命令，我们成功地删除了之前创建的文件，并再次验证了删除操作的正确性。

文件的删除是文件管理系统中的一个重要操作，需要谨慎操作，以免误删重要文件。

通过这一实验，我们进一步加深了对文件管理系统的理解，并学会了正确地进行文件的删除操作。

除了基本的文件管理操作外，我们还进行了一些高级操作的实验。

比如，我们尝试了文件的复制和移动操作。

通过使用相应的命令，我们成功地将一个文件复制到了另一个目录，并将一个文件移动到了另一个目录。

这些高级操作的实验使我们更加熟悉了文件管理系统的各种功能和操作，提高了我们的操作技能。

通过这次模拟实验，我们对操作系统的文件管理系统有了更深入的了解和掌握。

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

操作系统试验摹拟文件管理系统一、引言文件管理是操作系统中的重要组成部份，它负责对计算机中的文件进行组织、存储和访问。

摹拟文件管理系统是为了更好地理解文件管理的原理和实现方式而设计的一个实验项目。

本文将详细介绍摹拟文件管理系统的设计和实现。

二、设计目标1. 实现基本的文件管理功能，包括文件的创建、删除、打开和关闭。

2. 实现文件的读写操作，包括顺序读写和随机读写。

3. 实现文件的共享和保护机制，确保多个进程可以同时对同一个文件进行读写操作。

4. 实现文件的索引和目录结构，方便文件的查找和管理。

5. 实现文件的存储管理，包括空暇空间管理和磁盘分配算法。

三、系统设计1. 文件的创建和删除在摹拟文件管理系统中，可以通过命令行或者图形界面来创建和删除文件。

创建文件时，系统会为该文件分配一个惟一的文件标识符，并在文件目录中记录该文件的相关信息。

删除文件时，系统会释放该文件占用的存储空间，并从文件目录中删除该文件的记录。

2. 文件的打开和关闭在摹拟文件管理系统中，可以通过命令行或者图形界面来打开和关闭文件。

打开文件时，系统会根据文件标识符在文件目录中查找该文件的相关信息，并将该文件的描述符返回给用户进程。

关闭文件时，系统会释放该文件的描述符，并更新文件的相关信息。

3. 文件的读写操作在摹拟文件管理系统中，可以通过命令行或者图形界面来进行文件的读写操作。

顺序读写是指按照文件的存储顺序挨次读取或者写入文件的内容，而随机读写是指根据文件的索引或者偏移量来读取或者写入文件的内容。

系统会根据用户进程的读写请求，将相应的数据从磁盘中读取或者写入到内存中。

4. 文件的共享和保护机制在摹拟文件管理系统中，多个进程可以同时对同一个文件进行读写操作。

系统会通过锁机制来实现文件的共享和保护。

当一个进程正在对文件进行读写操作时，其他进程需要等待该进程释放文件的锁才干对文件进行读写操作。

同时，系统还可以设置文件的访问权限，确保惟独具有相应权限的进程才干对文件进行读写操作。

操作系统实验报告三

操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能，通过实际操作和观察，增强对操作系统原理的理解和掌握，提高解决实际问题的能力。

二、实验环境本次实验在 Windows 10 操作系统环境下进行，使用了 Visual Studio 2019 作为编程工具，并借助了相关的操作系统模拟软件和调试工具。

三、实验内容与步骤（一）进程管理实验1、创建多个进程使用 C+＋语言编写程序，通过调用系统函数创建多个进程。

观察每个进程的运行状态和资源占用情况。

2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。

分析在不同并发情况下程序的执行结果，理解进程同步的重要性。

（二）内存管理实验1、内存分配与回收实现一个简单的内存分配算法，如首次适应算法、最佳适应算法或最坏适应算法。

模拟内存的分配和回收过程，观察内存的使用情况和碎片产生的情况。

2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制，通过查看系统性能监视器观察虚拟内存的使用情况。

编写程序来模拟虚拟内存的页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。

（三）文件系统实验1、文件操作使用 C+＋语言对文件进行创建、读写、删除等操作。

观察文件在磁盘上的存储方式和文件目录的结构。

2、文件系统性能测试对不同大小和类型的文件进行读写操作，测量文件系统的读写性能。

分析影响文件系统性能的因素，如磁盘碎片、缓存机制等。

四、实验结果与分析（一）进程管理实验结果1、创建多个进程在创建多个进程的实验中，通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。

多个进程可以并发执行，提高了系统的资源利用率。

2、进程同步与互斥在生产者消费者问题的实验中，当使用正确的信号量机制时，生产者和消费者能够协调工作，不会出现数据不一致或死锁的情况。

文件管理实验报告

昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）课程名称：操作系统开课实验室：年月日一、实验目的用C或C++语言编写和调试一个简单的文件系统，模拟文件管理的基本功能。

从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。

二、实验原理及基本技术路线图（方框原理图）用C模拟实现文件系统的管理；要求设计一个多级目录结构的文件系统，能正确描述文件控制块，采用合理的外存分配方式，能实现基本的目录及文件的操作，包括创建、删除、重命名、复制、移动等功能，并对文件有一定的存取权限控制。

文件通常存放在外存（如磁盘、磁带）上，可以作为一个独立单位存放和实施相应的操作（如打开、关闭、读、写等）。

为了加快对文件的检索，往往将文件控制块集中在一起进行管理。

这种文件控制块的有序集合称为文件目录。

文件控制块就是其中的目录项。

下图示例一种目录的组织形式。

模拟一个文件系统，包括目录文件，普通文件，并实现对它们的一些基本操作。

假定每个目录文件最多只能占用一个块；一个目录项包括文件名（下一级目录名），文件类型，文件长度，指向文件内容（下一级目录）的指针内容。

普通文件可以只用目录项（FCB）代表。

三、所用仪器、材料（设备名称、型号、规格等）。

计算机一台四、实验方法、步骤//利用交互式命令实现树型目录结构和文件管理,同时利用位示图表示外存的分配情况，新建文件时分配必要的空间，模拟文件分配表记录文件在外存上的存储方式。

了解系统对文件的操作。

//在文件中保存目录内容，创建文件或子目录可以用命令行命令：MD、CD、RD、MK（创建文件）、DEL（删除文件）和DIR#include<iostream>#include<stdlib.h>#include<time.h>#include <locale.h>using namespace std;#define beginsize 5#define LENGTH 3typedef struct{i nt data[LENGTH];}Indireone;typedef struct{I ndireone * first[LENGTH];}Indiretwo;typedef struct{I ndiretwo * second[LENGTH]; }Indirethree;typedef struct Node{i nt begin[beginsize];I ndireone * one;I ndiretwo * two;I ndirethree * three;}Mixtab;typedef struct NODE{c har name[50];i nt type;//是文件还是目录i nt size;//如果是文件给出大小s truct NODE *next;//兄弟结点s truct NODE * sub;//子节点s truct NODE * father;//父亲节点M ixtab * table;}FCB;//文件控制块FCB * root;FCB * present;FCB * finding;char stringname[300];int Bitmap[16][16];//位示图int leftbit=0;void Initall(){i nt i,j;s rand( time(NULL) );f or(i=0;i<16;i++){//初始化位示图for(j=0;j<16;j++){Bitmap[i][j]=rand()%2;}}r oot=(FCB *)malloc(sizeof(FCB)); s trcpy(root->name,"\\");r oot->type=0;r oot->size=0;r oot->next=NULL;r oot->father=root;r oot->sub=NULL;f or(i=0;i<16;i++){for(j=0;j<16;j++){if(Bitmap[i][j]==0){leftbit++;}}}}//判断分配外存时候是不是足够int Judgeenough(int n){i f(leftbit>=n)return 1;e lse return 0;}//添加时候用void Addpoint(FCB * f){F CB * temp;i f(present->sub==NULL){present->sub=f;}e lse{temp=present->sub;while(temp->next!=NULL){temp=temp->next;}temp->next=f;f->next=NULL;}}//删除时候用void Delpoint(FCB *f){F CB * temp=present->sub;i f(temp==f){present->sub=temp->next;delete(f);}e lse{while(temp->next!=f){temp=temp->next;}temp->next=f->next;delete(f);}}//查找是不是已经存在int Isexist(char ary[],int x){F CB * temp;i f(present->sub==NULL){return 0;}e lse{temp=present->sub;while(temp!=NULL){if((!strcmp(temp->name,ary))&&(temp->type==x)){finding=temp;return 1;}temp=temp->next;}return 0;}}void Mdlist(){c har listname[50];c in>>listname;F CB * temp;i f(Isexist(listname,0)){cout<<"子目录或文件"<<listname<<"已存在。

《操作系统》模拟实验系统的设计与实现

为平台的实验系统，学生在学习课程原理的基础上，借助于ＩＤＥ可视化环境打开模拟系统的代码，进行算法的修改、补充等操作，通过实验结果深入分析模拟操作系
／／进程的优先级
ＰＭＭＰＡＳＰａｓ；
／／进程地址空间ＬＯＮＧｃｏｕｎｔｅｒ；／／进程已运行时间
关键词：操作系统；实验；进程；内存
据ｌｉｎｕｘ０．１１的结构，模拟ＯＳ十分小巧，结构清晰，但仍
引言
《操作系统》是计算机相关专业的一门专业基础
课，该课程概ቤተ መጻሕፍቲ ባይዱ多、较抽象，学生理解困难，单独讲授
然涵盖了进程管理、内存管理、文件管理等操作系统功
统的架构和源代码，充分激发学生的兴趣和主动性，从而加深学生对操作系统原理的理解，提高动手实践能力。每个实验代码中都留有一些接口，学生可根据算法原理编写代码，需要补充的代码一般在５０行左右。
一
ＬＯＮＧｐｒｉｏｒｉｙｔ
／／进程优先级
统，该系统是在麻省理工学院开放的课程平台下自主开发的实验系统：ＴｉｎｇＨｕａＯｐｅｒａｔｉｎｇＳｙｓｔｅｍＰｒｏｊｅｃｔ。
ｐｒｏｃｅｓｓ．ｈ是负责进程管理的头文件，将进程控制块和记录型信号量声明为结构体类型，ＰＣＢ中记录了进程的基本情况及对于进程控制的全部信息。当操作系统创
／／文
Ｌ０ＮＧＣｏｕｎｔ：

操作系统实验报告java

操作系统实验报告java操作系统实验报告一、实验目的本次实验旨在通过编写Java程序来实现一个简单的操作系统模拟，以加深对操作系统的理解。

二、实验环境- 操作系统：Windows 10- Java开发环境：Eclipse- 编程语言：Java三、实验内容⒈实现进程管理⑴进程创建⑵进程调度⑶进程同步⑷进程通信⒉实现内存管理⑴内存分配⑵内存回收⑶页面置换算法⒊文件系统管理⑴文件的创建与删除⑵文件的读写操作⑶文件权限控制四、实验步骤及代码实现⒈进程管理实现步骤⑴定义进程类⑵实现进程创建方法⑶实现进程调度方法⑷实现进程同步方法⑸实现进程通信方法⒉内存管理实现步骤⑴定义内存管理类⑵实现内存分配方法⑶实现内存回收方法⑷实现页面置换算法⒊文件系统管理实现步骤⑴定义文件类⑵实现文件的创建与删除方法⑶实现文件的读写操作方法⑷实现文件权限控制方法五、实验结果与分析在完成以上步骤后，我们成功实现了一个简单的操作系统模拟。

通过模拟进程管理、内存管理和文件系统管理等功能，可以更好地理解操作系统的工作原理和机制。

六、实验附件本实验报告附带Java程序源代码和运行结果截图，请参见附件。

七、法律名词及注释⒈操作系统：指一类管理计算机硬件和软件资源、控制程序运行的系统软件。

⒉进程：操作系统中的基本执行单位，每个进程拥有独立的地质空间和系统资源。

⒊进程调度：操作系统根据一定的策略和算法决定哪个进程在给定时刻执行。

⒋进程同步：多个进程之间的协调工作，保证数据的一致性和并发执行正确性。

⒌进程通信：进程之间通过某种方式交换信息和数据。

⒍内存分配：为进程分配内存空间，使其能够运行。

⒎内存回收：在进程终止或需要更多内存时，将内存空间释放。

⒏页面置换算法：在内存不足时，选择合适的页面进行置换以获取更多空闲内存。

⒐文件系统：操作系统管理文件和目录的组织和存储方式。

⒑文件的创建与删除：操作系统创建或删除文件，为文件分配或回收存储空间。

1⒈文件的读写操作：操作系统对文件进行读取或写入数据的操作。

操作系统课程实验报告

操作系统课程实验报告一、实验目的操作系统是计算机系统中最为关键的软件之一，它负责管理计算机的硬件资源和软件资源，为用户提供一个良好的工作环境。

通过操作系统课程实验，旨在深入理解操作系统的基本原理和功能，提高对操作系统的实际操作能力和问题解决能力。

二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 1804），开发工具包括 Visual Studio Code、gcc 编译器等。

三、实验内容（一）进程管理1、进程创建与终止在 Windows 系统中，使用 C+＋语言创建多个进程，并通过进程句柄控制进程的终止。

在 Linux 系统中，使用 fork(）系统调用创建子进程，并通过 exit(）函数终止进程。

2、进程同步与互斥使用信号量实现进程之间的同步与互斥。

在 Windows 中，利用CreateSemaphore(）和 WaitForSingleObject(）等函数进行操作；在Linux 中，通过 sem_init(）、sem_wait(）和 sem_post(）等函数实现。

（二）内存管理1、内存分配与释放在 Windows 中，使用 HeapAlloc(）和 HeapFree(）函数进行动态内存的分配与释放。

在 Linux 中，使用 malloc(）和 free(）函数完成相同的操作。

2、内存页面置换算法实现了几种常见的内存页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等，并比较它们的性能。

（三）文件系统管理1、文件创建与读写在 Windows 和 Linux 系统中，分别使用相应的 API 和系统调用创建文件，并进行读写操作。

2、目录操作实现了目录的创建、删除、遍历等功能。

四、实验步骤（一）进程管理实验1、进程创建与终止（1）在 Windows 系统中，编写 C+＋程序，使用 CreateProcess(）函数创建新进程，并通过 TerminateProcess(）函数终止指定进程。

《操作系统》课程综合性的实验报告

《操作系统》课程综合性的实验报告一、实验目的本次《操作系统》课程的综合性实验旨在通过实际操作和实践，深入理解操作系统的基本原理、功能和运行机制。

具体目标包括熟悉操作系统的进程管理、内存管理、文件系统管理以及设备管理等核心模块，提高对操作系统的整体认知和应用能力。

二、实验环境本次实验在以下环境中进行：操作系统：Windows 10 专业版开发工具：Visual Studio 2019编程语言：C+＋三、实验内容及步骤（一）进程管理实验1、创建多个进程使用 C+＋中的多线程库，创建多个进程，并观察它们的并发执行情况。

通过设置不同的优先级和资源需求，研究进程调度算法对系统性能的影响。

2、进程同步与互斥实现生产者消费者问题，使用信号量、互斥锁等机制来保证进程之间的同步和互斥。

观察在不同并发情况下，数据的正确性和系统的稳定性。

（二）内存管理实验1、内存分配与回收模拟内存分配算法，如首次适应算法、最佳适应算法和最坏适应算法。

通过随机生成内存请求，观察不同算法下内存的利用率和碎片情况。

2、虚拟内存管理研究虚拟内存的工作原理，通过设置页面大小和页表结构，观察页面置换算法（如 FIFO、LRU 等）对内存访问性能的影响。

（三）文件系统管理实验1、文件操作创建、读取、写入和删除文件，了解文件系统的基本操作和数据结构。

2、文件目录管理实现文件目录的创建、遍历和搜索功能，研究目录结构对文件访问效率的影响。

（四）设备管理实验1、设备驱动程序模拟编写简单的设备驱动程序，模拟设备的输入输出操作，如键盘输入和屏幕输出。

2、设备分配与调度研究设备分配算法，如先来先服务和优先级算法，观察设备的使用情况和系统的响应时间。

四、实验结果与分析（一）进程管理实验结果分析1、在创建多个进程的实验中，发现高优先级进程能够更快地获得CPU 资源，系统响应时间更短。

但过度提高某些进程的优先级可能导致其他进程饥饿。

2、对于进程同步与互斥问题，正确使用信号量和互斥锁能够有效地保证数据的一致性和系统的稳定性。

操作实验系统实验报告

实验名称：操作实验系统实验日期：2023年3月15日实验地点：XX大学计算机实验室实验目的：1. 熟悉实验系统的基本操作流程。

2. 掌握实验系统的基本功能使用方法。

3. 培养动手实践能力和团队协作精神。

实验原理：实验系统是一种模拟真实工作环境的软件平台，通过该平台可以完成各种实验任务。

本实验系统基于Windows操作系统，采用C#语言开发，具有图形界面和丰富的功能模块。

实验内容：1. 系统启动与关闭2. 系统界面熟悉3. 功能模块使用4. 实验任务完成实验步骤：一、系统启动与关闭1. 打开实验系统所在的文件夹，找到实验系统可执行文件。

2. 双击可执行文件，系统开始加载，出现启动界面。

3. 系统加载完成后，进入主界面。

4. 完成实验任务后，点击“退出”按钮，系统开始关闭。

二、系统界面熟悉1. 观察主界面，了解系统各个功能模块的布局。

2. 点击各个功能模块，了解其功能及使用方法。

3. 查看系统帮助文档，了解系统功能和使用技巧。

三、功能模块使用1. 数据管理模块：（1）创建数据表：点击“创建数据表”按钮，输入数据表名称，选择数据类型，点击“确定”按钮。

（2）添加数据：选择数据表，点击“添加数据”按钮，输入数据，点击“保存”按钮。

（3）查询数据：选择数据表，点击“查询数据”按钮，输入查询条件，点击“查询”按钮。

2. 图形处理模块：（1）打开图片：点击“打开图片”按钮，选择要处理的图片。

（2）图片编辑：对图片进行缩放、裁剪、旋转等操作。

（3）保存图片：点击“保存图片”按钮，选择保存路径和文件名，点击“保存”按钮。

3. 文本处理模块：（1）打开文本文件：点击“打开文本文件”按钮，选择要处理的文本文件。

（2）文本编辑：对文本进行复制、粘贴、删除等操作。

（3）保存文本：点击“保存文本”按钮，选择保存路径和文件名，点击“保存”按钮。

四、实验任务完成1. 根据实验要求，选择合适的功能模块。

2. 完成实验任务，记录实验数据。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

3.实验提示（1）首先应确定文件系统的数据结构：主目录、子目录及活动文件等。

主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。

（2）用户创建的文件，可以编号存储于磁盘上。

入file0,file1,file2…并以编号作为物理地址，在目录中进行登记。

4.源代码#include<stdio.h>#include<string.h>#include<stdlib.h>#define MEM_D_SIZE 1024*1024 //总磁盘空间为1M#define DISKSIZE 1024 //磁盘块的大小1K#define DISK_NUM 1024//磁盘块数目1K#define FATSIZE DISK_NUM*sizeof(struct fatitem) //FAT表大小#define ROOT_DISK_NO FATSIZE/DISKSIZE+1//根目录起始盘块号#define ROOT_DISK_SIZE sizeof(struct direct) //根目录大小#define DIR_MAXSIZE 1024//路径最大长度为1KB#define MSD 5//最大子目录数5#define MOFN 5//最大文件深度为5#define MAX_WRITE 1024*128//最大写入文字长度128KB struct fatitem /* size 8*/{int item; /*存放文件下一个磁盘的指针*/char em_disk; /*磁盘块是否空闲标志位0 空闲*/};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];};struct opentable{struct openttableitem{char name[9]; /*文件名*/int firstdisk; /*起始盘块号*/int size; /*文件的大小*/ }openitem[MOFN];int cur_size; /*当前打文件的数目*/}; struct fatitem *fat; /*FAT表*/ struct direct *root; /*根目录*/ struct direct *cur_dir; /*当前目录*/ struct opentable u_opentable; /*文件打开表*/int fd=-1; /*文件打开表的序号*/ char *bufferdir; /*记录当前路径的名称*/char *fdisk; /*虚拟磁盘起始地址*/ 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();void initfile(){fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请1M空间*/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<ROOT_DISK_NO-1;i++) /*存放FAT表的磁盘块号*/{fat[i].item=i+1;fat[i].em_disk='1';}fat[ROOT_DISK_NO].item=-1;/*存放根目录的磁盘块号*/fat[ROOT_DISK_NO].em_disk='1';for(i=ROOT_DISK_NO+1;i<DISK_ NUM;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<MSD+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);}void enter(){FILE *fp;int i;fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请1M空间*/if((fp=fopen("disk.dat","rb"))==N ULL){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<MOFN;i++){strcpy(u_opentable.openitem[i].n ame,"");u_opentable.openitem[i].firstdisk = -1;u_opentable.openitem[i].size = 0;}u_opentable.cur_size = 0;cur_dir = root; /*当前目录为根目录*/bufferdir = (char *)malloc(DIR_MAXSIZE*sizeof(char));strcpy(bufferdir,"Root:");}void halt(){FILE *fp;int i;if((fp=fopen("disk.dat","wb"))==N ULL){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;}int create(char *name){int i,j;if(strlen(name)>8) /*文件名大于8位*/return(-1);for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/ {if(!strcmp(cur_dir->directitem[j].n ame,name))break;}if(j<MSD+2) /*文件已经存在*/return(-4);for(i=2;i<MSD+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<DISK_NUM ;j++) /*找到空闲盘块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,na me);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;} int open(char *name){int i, j;for(i=2;i<MSD+2;i++) /*文件是否存在*/{if(!strcmp(cur_dir->directitem[i].n ame,name))break;}if(i>=MSD+2)return(-1);/*--------是文件还是目录-----------------------*/if(cur_dir->directitem[i].property= ='1')return(-4);/*--------文件是否打开-----------------------*/for(j=0;j<MOFN;j++){if(!strcmp(u_opentable.openitem[ j].name,name))break;}if(j<MOFN) /*文件已经打开*/return(-2);if(u_opentable.cur_size>=MOFN) /*文件打开太多*/return(-3);/*--------查找一个空闲用户打开表项-----------------------*/ for(j=0;j<MOFN;j++){if(u_opentable.openitem[j].firstdis k==-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);}int close(char *name){int i;for(i=0;i<MOFN;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;}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<len;i++){if(buf[i] == '$')buf[i] = Space;else if(buf[i] == '#')buf[i] = Endter;}/*----------读取用户打开表对应表项第一个盘块号-----------------------*/item = u_opentable.openitem[fd].firstdisk;/*-------------找到当前目录所对应表项的序号-------------------------*/for(i=2;i<MSD+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.ope nitem[fd].size%DISKSIZE;/*-----如果最后磁盘块剩余的大小大于要写入的文件的大小-------*/ if(DISKSIZE-u_opentable.openite m[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<ilen2;j++){for(i=ROOT_DISK_NO+1;i<DISK_ NUM;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<len-(DISKSIZE-u_opent able.openitem[fd].size%DISKSIZE)-j*DI SKSIZE;k++)first[k] = buf[k];}else/*-如果不是要最后分配的一块--*/{for(k=0;k<DISKSIZE;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;}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<ilen1;i++){if(i==ilen1-1) /*--如果在最后一个磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];}else /*--不在最后一块磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];item = fat[item].item; /*-查找下一盘块-*/first = fdisk+item*DISKSIZE;}}return 0;}int del(char *name){int i,cur_item,item,temp;for(i=2;i<MSD+2;i++) /*--查找要删除文件是否在当前目录中-*/{if(!strcmp(cur_dir->directitem[i].n ame,name))break;}cur_item = i; /*--用来保存目录项的序号,供释放目录中-*/if(i>=MSD+2) /*--如果不在当前目录中-*/return(-1);if(cur_dir->directitem[cur_item].p roperty!='0') /*--如果删除的(不)是目录-*/return(-3);for(i=0;i<MOFN;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].first disk = -1;strcpy(u_opentable.openitem[cur_ item].name,"");cur_dir->directitem[cur_item].next = -1; cur_dir->directitem[cur_item].propert y = '0';cur_dir->directitem[cur_item].size = 0;return 0;}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<MSD+2;i++) /*-如果有空闲目录项退出-*/{if(cur_dir->directitem[i].firstdisk== -1)break;}if(i>=MSD+2) /*-目录/文件已满-*/return(-2);for(j=2;j<MSD+2;j++) /*-判断是否有重名-*/{if(!strcmp(cur_dir->directitem[j].n ame,name))break;}if(j<MSD+2) /*-如果有重名-*/return(-3);for(j=ROOT_DISK_NO+1;j<DISK_ NUM;j++) /*-找到空闲磁盘块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].n ame,".");cur_mkdir->directitem[0].next=cu r_mkdir->directitem[0].firstdisk;cur_mkdir->directitem[0].propert y='1';cur_mkdir->directitem[0].size=RO OT_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].n ame,"..");cur_mkdir->directitem[1].next=cur _mkdir->directitem[1].firstdisk;cur_mkdir->directitem[1].property ='1';cur_mkdir->directitem[1].size=RO OT_DISK_SIZE;for(i=2;i<MSD+2;i++) /*-子目录都初始化为空-*/{cur_mkdir->directitem[i].sign=0;cur_mkdir->directitem[i].firstdisk= -1;strcpy(cur_mkdir->directitem[i].na me,"");cur_mkdir->directitem[i].next=-1;cur_mkdir->directitem[i].property ='0';cur_mkdir->directitem[i].size=0;}return 0;}int rmdir(char *name){int i,j,item;struct direct *temp_dir;/*-检查当前目录项中有无该目录-*/for(i=2;i<MSD+2;i++){if(!strcmp(cur_dir->directitem[i].n ame,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*DI SKSIZE);for(j=2;j<MSD+2;j++){if(temp_dir->directitem[j].next!=-1)break;}if(j<MSD+2) /*-有子目录或文件-*/return(-2);/*------------找到起始盘块号,并将其释放----------------*/item=cur_dir->directitem[i].firstdis k;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;}void dir(){int i;for(i=2;i<MSD+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->directite m[i].size);elseprintf("\t<目录>\t\n");}}}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;}temp = (char *)malloc(DIR_MAXSIZE*sizeof(char)); /*-最长路径名字分配空间-*/for(i=0;i<(int)strlen(str);i++)temp[i]=str[i];temp[i]='\0';for(j=0;j<MSD+2;j++) /*-查找该子目录是否在当前目录中-*/{if(!strcmp(temp_dir->directitem[j] .name,temp))break;}free(temp);/*释放申请的临时空间*///if(temp_dir->directitem[j].prope rty!='1') /*-打开的不是目录-*///return(-2);if(j>=MSD+2) /*-不在当前目录-*/return(-1);item=temp_dir->directitem[j].first disk;/*-当前目录在磁盘中位置-*/temp_dir=(struct direct *)(fdisk+item*DISKSIZE);if(!strcmp("..",name)){if(cur_dir->directitem[j-1].sign!=1) /*-如果上级目录不是根目录-*/{point=strchr(bufferdir,'\\'); //查找字符串bufferdir中首次出现字符\ 的位置while(point!=NULL){point1=point+1; /*-减去'\'所占的空间,记录下次查找的起始地址-*/point=strchr(point1,'\\');}*(point1-1)='\0'; /*-将上一级目录删除-*/}}else{//if(name[0] !='\\')bufferdir = strcat(bufferdir,"\\"); /*-修改当前目录-*/bufferdir = strcat(bufferdir,name);}cur_dir=temp_dir; /*-将当前目录确定下来-*/return 0;}void show(){printf("%s>",bufferdir);}void print(){printf("********************************** ***********************\n");printf("**********************文件系统设计***********************\n");printf("*\t命令格式说明*\n");printf("*\tcd 目录名更改当前目录*\n");printf("*\tmkdir 目录名创建子目录*\n");printf("*\trmdir 目录名删除子目录*\n");printf("*\tdir 显示当前目录的子目录*\n");printf("*\tcreate 文件名创建文件*\n");printf("*\tdel 文件名删除文件*\n");printf("*\topen 文件名打开文件*\n");printf("*\tclose 文件名关闭文件*\n");printf("*\tread 读文件*\n");printf("*\twrite 写文件*\n");printf("*\texit 退出系统*\n");printf("********************************** ***********************\n");} void main(){FILE *fp;char ch;char a[100];char code[11][10];char name[10];int i,flag,r_size;char *contect;contect = (char *)malloc(MAX_WRITE*sizeof(char));if((fp=fopen("disk.dat","rb"))==N ULL){printf("You have not format,Do you want format?(y/n)");scanf("%c",&ch);if(ch=='y'){initfile();printf("Successfully format!\n");}else{return;}}enter();print();show();strcpy(code[0],"exit"); strcpy(code[1],"create"); strcpy(code[2],"open"); strcpy(code[3],"close"); strcpy(code[4],"write"); strcpy(code[5],"read"); strcpy(code[6],"del"); strcpy(code[7],"mkdir"); strcpy(code[8],"rmdir"); strcpy(code[9],"dir"); strcpy(code[10],"cd");while(1){scanf("%s",a);for(i=0;i<11;i++){if(!strcmp(code[i],a))break;}switch(i){case 0: //退出文件系统free(contect);halt();return;case 1: //创建文件scanf("%s",name);flag = create(name);if(flag==-1){printf("Error: \n The length is too long !\n");}else if(flag==-2){printf("Error: \n The direct item is already full !\n");}else if(flag==-3){printf("Error: \n The number of openfile is too much !\n");}else if(flag==-4){printf("Error: \n The name is already in the direct !\n");}else if(flag==-5){printf("Error: \n The disk space is full!\n");}else{printf("Successfully create a file! \n");}show();break;case 2://打开文件scanf("%s",name);fd = open(name);if(fd == -1){printf("Error: \n The open file not exit! \n");}else if(fd == -2){printf("Error: \n The file have already opened! \n");}else if(fd == -3){printf("Error: \n The number of open file is too much! \n");}else if(fd == -4){printf("Error: \n It is a direct,can not open for read or write! \n");}else{printf("Successfully opened! \n");}show();break;case 3://关闭文件scanf("%s",name);flag = close(name);if(flag == -1){printf("Error:\n The file is not opened ! \n");}else{printf("Successfully closed! \n");}show();break;case 4://写文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}else{printf("Please input the file contect:");scanf("%s",contect);flag=write(fd,contect,strlen(contect));if(flag == 0){printf("Successfully write! \n");}else{printf("Error:\n The disk size is not enough! \n");}}show();break;case 5://读文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}else{flag = read(fd,contect);if(flag == 0){for(i=0;i<u_opentable.openitem[fd ].size;i++){printf("%c",contect[i]);}printf("\t\n");}}show();break;case 6://删除文件scanf("%s",name);flag = del(name);if(flag == -1){printf("Error:\n Thefile not exit! \n");}else if(flag == -2){printf("Error:\n The file is opened,please first close it ! \n");}else if(flag == -3){printf("Error:\n The delete is not file ! \n");}else{printf("Successfully delete! \n");}show();break;case 7://创建子目录scanf("%s",name);flag = mkdir(name);if(flag == -1){printf("Error:\n The length of name is to long! \n");}else if(flag == -2){printf("Error:\n The direct item is already full ! \n");}else if(flag == -3){printf("Error:\n The name is already in the direct ! \n");}else if(flag == -4){printf("Error: \n '..' or '.' can not as the name of the direct!\n");}else if(flag == -5){printf("Error: \n The disk space is full!\n");}else if(flag == 0){printf("Successfully make dircet! \n");}show();break;case 8://删除子目录scanf("%s",name);flag = rmdir(name);if(flag == -1){printf("Error:\n The direct is not exist! \n");}else if(flag == -2){printf("Error:\nThe direct has son direct ,please first remove the son dircct!\n");}else if(flag == -3){printf("Error:\n The remove is not direct ! \n");}else if(flag == 0){printf("Successfully remove dircet! \n");}show();break;case 9://显示当前子目录dir();show();break;case 10://更改当前目录scanf("%s",name);flag = cd(name);if(flag == -1){printf("Error:\n The path no correct!\n");}else if(flag == -2){printf("Error:\nThe opened is not direct!\n");}show();break;default:printf("\n Error!\n The command is wrong! \n");show();}}}5.程序运行截图实验二存储管理动态分区分配及回收算法页脚内容6.实验总结通过这一次计算机操作系统的上机实验，使我对不同环境下的操作系统有了进一步的了解，使我学到了很多关于Linux 的操作和相关知识。