下载文档原格式
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 Windows 10 专业版，开发工具为Visual Studio 2019，编程语言为 C 和 C+＋。
实验硬件环境为一台配备Intel Core i7 处理器、16GB 内存、512GB SSD 硬盘的个人计算机。
三、实验内容（一）进程管理实验1、进程创建与终止通过编程实现创建新的进程，并在完成任务后终止进程。
在实验中，我们使用了 Windows API 函数 CreateProcess 和 TerminateProcess 来完成进程的创建和终止操作。
通过观察进程的创建和终止过程，深入理解了进程的生命周期和状态转换。
2、进程同步与互斥为了实现进程之间的同步与互斥，我们使用了信号量、互斥量等同步对象。
通过编写多线程程序，模拟了多个进程对共享资源的访问，实现了对共享资源的互斥访问和同步操作。
在实验中，我们深刻体会到了进程同步与互斥的重要性，以及不正确的同步操作可能导致的死锁等问题。
（二）内存管理实验1、内存分配与释放使用 Windows API 函数 VirtualAlloc 和 VirtualFree 进行内存的分配和释放操作。
通过实验，了解了内存分配的不同方式（如堆分配、栈分配等）以及内存释放的时机和方法，掌握了内存管理的基本原理和操作技巧。
2、内存分页与分段通过编程模拟内存的分页和分段管理机制，了解了内存分页和分段的基本原理和实现方法。
在实验中，我们实现了简单的内存分页和分段算法，对内存的地址转换和页面置换等过程有了更深入的理解。
（三）文件系统实验1、文件操作使用 Windows API 函数 CreateFile、ReadFile、WriteFile 等进行文件的创建、读取和写入操作。
课内实验报告课程名：操作系统任课教师：沈超专业：信息管理与信息系统学号：姓名：二○一六至二○一七年度第一学期南京邮电大学经济与管理学院Process[numberschedul].order=tempcounter;}程序结果截图：二、银行家算法（网上借鉴）银行家算法，当进程提出资源申请时，系统首先检查该进程对资源的申请量是否超过其最大需求量及系统现有的资源能否满足进程需要。
若超过，则报错，若不能满足，则让该进程等待；否则进一步检查把资源分给该进程后系统能否出于安全状态，若安全，则分配，否则置该进程为等待资源状态。
算法实现过程：设进程i 提出请求REQUEST [j] ，则银行家算法按如下规则进行判断。
(1) 如果REQUEST [i] [j]<= NEED[i][j] ，则转(2) ；否则，出错。
(2) 如果REQUEST [i] [j]<= A V AILABLE[i][j] ，则转(3) ；否则，出错。
(3) 系统试探分配资源，修改相关数据：A V AILABLE[j]-=REQUEST[i][j];ALLOCATION[i][j]+=REQUEST[i][j];NEED[i][j]-=REQUEST[i][j];(4) 系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。
Check（）关键代码：{int k, f, no=0;int work[M],a[M];char finish[M];anquan=1;for(i=0;i<n; i++) finish[i]='F';for(j=0;j<m; j++) work[j]=available[j]; k=n;do{ for (i=0;i<n; i++){if (finish[i]=='F'){ f=1;for (j=0;j<m; j++)if (need[i][j]>work[j]) printf("处于安全状态.");printf("安全序列号:");for (i=0;i<n;i++) printf ("%d ",a[i]); printf("\n");printf("进程");printf(" ");printf(" Max ");rintf(" ");rintf("allocation");printf(" ");printf("need");printf(" ");f=0;if (f==1)//找到还没完成的且需求数小于可提供进程继续运行的{ finish[i]='T';a[no++]=i;//记录安全序列号for (j=0;j<m; j++)work[j]=work[j]+allocation[i][j];//释放该进程已分配的资源available[j] =work[j];}}}k--; }while(k>0);f=1;for (i=0;i<n; i++)//判断有没有进程没完成{ if (finish[i]=='F'){f=0;break; }} if (f==0) {printf("不安全状态！\n");anquan=0;} else {printf("available");printf("\n");for (i=0;i<n; i++){ printf("%2d",i);printf(" ");for(j=0;j<m; j++)printf("%2d",max[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",allocation[i][j]);printf(" ");for(j=0;j<m; j++)printf("%2d",need[i][j]);printf(" ");for(j=0;j<m; j++){if(i>0)break;printf("%2d",available[j]);}printf("\n");}}}程序结果截图：三、实验总结：这次上机模拟了进程调度过程和解决了死锁问题，让我对短作业优先调度算法和银行家算法有了比在课堂上更深刻的认识。
文件管理系统模拟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］。
操作系统文件管理系统模拟实验操作系统文件管理系统模拟实验一、实验目的本实验旨在通过模拟操作系统的文件管理系统，加深对操作系统文件管理的理解，锻炼操作系统的应用能力。
二、实验环境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、进行文件操作和目录操作。
五、实验结果分析根据实验步骤进行文件操作和目录操作，观察系统的运行情况并记录相关实验结果。
六、实验结论通过本实验，深入了解了操作系统中文件管理系统的相关原理和实现方式，并且通过实验操作进一步巩固了相应的应用能力。
第1篇一、引言操作系统是计算机科学与技术领域的重要基础课程，它涉及计算机系统的资源管理、进程管理、存储管理、文件系统等多个方面。
为了提高学生对操作系统的理解和掌握程度，本文将从教学实践的角度，探讨如何进行操作系统教学。
二、教学目标1. 使学生掌握操作系统的基本概念、原理和关键技术；2. 培养学生分析和解决实际问题的能力；3. 增强学生的团队协作和创新能力；4. 提高学生的编程能力和动手能力。
三、教学内容1. 操作系统概述：介绍操作系统的定义、发展历程、分类和特点；2. 进程管理：讲解进程的概念、进程状态、进程调度算法和进程同步与互斥；3. 存储管理：分析内存分配策略、页面置换算法和虚拟内存技术；4. 文件系统：探讨文件系统的概念、目录结构、文件操作和存储设备管理；5. 设备管理：介绍设备的分类、驱动程序、I/O控制方式和中断处理；6. 网络操作系统：讲解网络操作系统的基本概念、网络协议、网络设备管理和网络安全。
四、教学实践1. 案例教学：通过实际案例，引导学生分析操作系统的原理和应用。
例如，以Linux系统为例，讲解进程调度、内存管理和文件系统等知识点。
2. 实验教学：设计实验项目，让学生动手实践操作系统的相关知识。
实验项目包括：（1）进程调度实验：让学生编写进程调度算法，实现进程的创建、调度和同步。
（2）内存管理实验：让学生实现内存分配、页面置换和虚拟内存等技术。
（3）文件系统实验：让学生实现文件系统的目录结构、文件操作和存储设备管理。
（4）设备管理实验：让学生编写设备驱动程序，实现设备的控制和管理。
3. 项目教学：以实际项目为背景，让学生分组完成项目开发。
项目可以包括：（1）操作系统模拟器：让学生模拟操作系统的运行过程，加深对操作系统原理的理解。
（2）嵌入式操作系统开发：让学生了解嵌入式操作系统的特点，掌握嵌入式开发技能。
（3）分布式操作系统开发：让学生了解分布式系统的原理，掌握分布式操作系统的开发方法。
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
}
五、编译过程截图
（下面是一个例子，换上你自己的图）
六、测试用例
（下面是一个例子，换上你自己的）
文字叙述一下测试过程的实例。
如先创建用户***、再产生文件****、再打开文件****，再写入内容********，再退出，再打开用户***，再将文件读出，读出的内容应该是*******。
等等。
六、实验结果
（下面是一个例子，换上你自己的图，给出根据测试用例的截图）。
linux系统使用实验报告Linux 系统使用实验报告一、实验目的本次实验旨在深入了解和熟悉 Linux 操作系统的基本操作、命令行使用以及系统配置，掌握常见的文件管理、进程管理、用户权限管理等功能，提高对 Linux 系统的实际应用能力。
二、实验环境1、操作系统：Ubuntu 2004 LTS2、实验工具：终端模拟器（Terminal）三、实验内容与步骤（一）系统登录与基本命令1、启动计算机，选择 Ubuntu 操作系统，输入用户名和密码登录系统。
2、打开终端模拟器，熟悉常用的基本命令，如｀ls` （列出当前目录下的文件和文件夹）、｀cd` （切换目录）、｀mkdir` （创建新目录）、｀rmdir` （删除空目录）等。
（二）文件管理1、在用户主目录下创建一个名为｀experiment` 的文件夹，使用｀mkdir experiment` 命令。
2、进入该文件夹，使用｀cd experiment` 命令。
3、在｀experiment` 文件夹中创建一个文本文件｀filetxt` ，使用｀touch filetxt` 命令。
4、使用｀vi` 或｀nano` 编辑器打开｀filetxt` 文件，输入一些文本内容，并保存退出。
5、查看文件的内容，使用｀cat filetxt` 命令。
6、复制文件，使用｀cp filetxt file_copytxt` 命令。
7、移动文件，使用｀mv filetxt／｀命令将文件移动到上级目录。
8、删除文件，使用｀rm file_copytxt` 命令。
（三）进程管理1、运行一个后台进程，例如｀ping ＆｀，然后使用｀jobs` 命令查看后台进程。
2、将后台进程切换到前台，使用｀fg ％1` （其中％1 为后台进程的编号）命令。
3、终止进程，使用｀Ctrl ＋ C` 组合键终止正在运行的进程。
4、查看系统当前运行的进程，使用｀ps aux` 命令。
（四）用户权限管理1、创建一个新用户，使用｀sudo adduser username` 命令，其中｀username` 为新用户的用户名。
《操作系统》课程实验报告一、实验目的本次《操作系统》课程实验的主要目的是通过实际操作和观察，深入理解操作系统的工作原理、进程管理、内存管理、文件系统等核心概念，并掌握相关的操作技能和分析方法。
二、实验环境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.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
操作系统实训报告一、实训背景操作系统是计算机系统中最基本的软件之一，它负责管理计算机系统的各种资源，如内存、CPU、磁盘等。
为了更好地掌握操作系统的原理和实现，我们在课程中进行了一系列的操作系统实训。
二、实训内容1. 实验环境搭建在开始实验之前，我们需要先搭建好实验环境。
我们使用了虚拟机软件VMware Workstation来模拟一个计算机系统，并安装了Ubuntu 操作系统作为我们的实验平台。
2. 实验任务在本次实训中，我们主要完成了以下几个任务：（1）进程管理：通过编写一个简单的C程序来模拟进程创建、销毁和调度等操作。
（2）内存管理：通过编写一个简单的C程序来模拟内存分配和回收等操作。
（3）文件系统：通过使用Linux命令行工具来创建、读取和删除文件，并学习了文件权限管理等知识。
三、实训过程1. 进程管理首先，我们使用C语言编写了一个简单的程序，用于模拟进程创建和销毁。
程序首先创建一个父进程，并利用fork()函数创建两个子进程。
然后，父进程等待子进程结束后输出一条消息并退出。
接着，我们修改了程序，使用了wait()函数来实现进程调度。
wait()函数可以让父进程等待子进程结束后再继续执行。
我们在程序中使用了两个wait()函数来实现进程的顺序执行。
最后，我们添加了一个信号处理函数，用于处理子进程结束时发送的SIGCHLD信号。
信号处理函数可以在子进程结束时立即执行，不需要等待父进程调度。
2. 内存管理接下来，我们使用C语言编写了一个简单的程序，用于模拟内存分配和回收。
程序首先创建一个指向整型数组的指针，并使用malloc()函数动态分配一块内存。
然后，在内存中写入一些数据，并输出到屏幕上。
最后，使用free()函数释放内存并退出程序。
在编写程序时，我们注意到malloc()和free()函数是操作系统提供的内存管理接口。
malloc()函数可以动态分配一块指定大小的内存，并返回一个指向该内存区域的指针；而free()函数可以释放之前分配的内存。
操作系统实验报告范文模板这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。
里面的程序都是我运行过的。
操作系统上机实验报告班级：学号：姓名：实验地点：实验时间：这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。
里面的程序都是我运行过的。
实验一进程的建立【实验目的】创建进程及子进程在父子进程间实现进程通信【实验软硬件环境】Linu某、Window98、Window2000【实验内容】创建进程并显示标识等进程控制块的属性信息；显示父子进程的通信信息和相应的应答信息。
（进程间通信机制任选）【实验程序及分析】编程思路：首先本程序在Linu某用C语言完成的，父子进程的创建用fork函数来实现，然后是父子进程间的通信，这里用pipe实现。
可以定义chan1[2],chan1[2],chan某[0]表示读，chan某[1]表示写。
他们配合使用。
【实验截图】【实验心得体会】通过这次上机练习，我熟悉了用c++实现进程的创建，销毁，父子进程间的通讯等一系列课程中需要学习的内容。
本来进程的概念在一开始我始终无法清晰地理解，但是通过自己用mfc的方法去实现它后，我开始慢慢地理解操作系统的进程的运作机制。
虽然，我只是实现了一个父子进程的创建和通讯，但是，管中窥豹，我想自己开始明白一个操作系统正是由很多这种进程实现功能的。
其中，系统整体的进程调度，管理等等还有很多东西等着我们去进一步学习、理解。
实验二进程间的同步【实验目的】这是操作系统课程中的四次实验最终报告,内包括进程通信实验,进程同步互斥实验,文件系统模拟实验和Linu某hell操作。
里面的程序都是我运行过的。
理解进程同步和互斥模型及其应用【实验软硬件环境】Linu某、Window98、Window2000【实验内容】利用通信API实现进程之间的同步：建立司机和售票员进程；并实现他们间的同步运行。
操作系统试验摹拟文件管理系统一、引言文件管理是操作系统中的重要组成部份，它负责对计算机中的文件进行组织、存储和访问。
摹拟文件管理系统是为了更好地理解文件管理的原理和实现方式而设计的一个实验项目。
本文将详细介绍摹拟文件管理系统的设计和实现。
二、设计目标1. 实现基本的文件管理功能，包括文件的创建、删除、打开和关闭。
2. 实现文件的读写操作，包括顺序读写和随机读写。
3. 实现文件的共享和保护机制，确保多个进程可以同时对同一个文件进行读写操作。
4. 实现文件的索引和目录结构，方便文件的查找和管理。
5. 实现文件的存储管理，包括空暇空间管理和磁盘分配算法。
三、系统设计1. 文件的创建和删除在摹拟文件管理系统中，可以通过命令行或者图形界面来创建和删除文件。
创建文件时，系统会为该文件分配一个惟一的文件标识符，并在文件目录中记录该文件的相关信息。
删除文件时，系统会释放该文件占用的存储空间，并从文件目录中删除该文件的记录。
2. 文件的打开和关闭在摹拟文件管理系统中，可以通过命令行或者图形界面来打开和关闭文件。
打开文件时，系统会根据文件标识符在文件目录中查找该文件的相关信息，并将该文件的描述符返回给用户进程。
关闭文件时，系统会释放该文件的描述符，并更新文件的相关信息。
3. 文件的读写操作在摹拟文件管理系统中，可以通过命令行或者图形界面来进行文件的读写操作。
顺序读写是指按照文件的存储顺序挨次读取或者写入文件的内容，而随机读写是指根据文件的索引或者偏移量来读取或者写入文件的内容。
系统会根据用户进程的读写请求，将相应的数据从磁盘中读取或者写入到内存中。
4. 文件的共享和保护机制在摹拟文件管理系统中，多个进程可以同时对同一个文件进行读写操作。
系统会通过锁机制来实现文件的共享和保护。
当一个进程正在对文件进行读写操作时，其他进程需要等待该进程释放文件的锁才干对文件进行读写操作。
同时，系统还可以设置文件的访问权限，确保惟独具有相应权限的进程才干对文件进行读写操作。
操作系统实验报告（一）Linux基本操作与编程（验证性 2学时）1、实验目(de)：1）熟悉Linux操作系统(de)环境和使用.2）了解LINUX系统(de)安装过程.（注：表示可选择）3）掌握Linux环境下(de)命令操作.2、实验内容：（1）完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求：结果以屏幕截图表示).1）运行pwd命令,确定你当前(de)工作目录.2）利用以下命令显示当前工作目录(de)内容： ls –l3）运行以下命令： ls –al4）使用mkdir命令建立一个子目录subdir.5）使用cd命令,将工作目录改到根目录（/）上.6）使用ls-l命令列出/dev(de)内容.7）使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8）使用命令cd ../..,你将工作目录移到什么地方（2）在LINUX下查看你(de)文件.1）利用cd命令,将工作目录改到你(de)主目录上.2）将工作目录改到你(de)子目录subdir,然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中.3）使用cat命令查看file1文件(de)内容.4）利用man命令显示date命令(de)用法： man date5）将date命令(de)用法附加到文件file1(de)后面：man date >> file16）利用cat命令显示文件file1(de)内容.7）利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8）利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9）利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10）用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.（3）编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤：1）在文本编辑器中,编写C程序如下：include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下：./a（4）编写一个程序：显示信息“Time for Play”,并能在后台运行一段时间（自定义）后,弹出信息提醒用户.要求记录所使用(de)命令及结果.（提示：使用sleep(s)函数）3、实验结果分析：（对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题）（1）进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性（2）在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行；正在运行(de)命令,使用Ctrl+z ,就挂起； jobs命令,可以现实后台,包括挂起(de)命令；使用 bg %作业号就可以把挂起(de)命令在后台执行；使用 fg %作业号就可以把后台命令调到前台（3）你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013（4）你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结：你对本次实验有什么体会或看法.操作系统实验报告（二）文件访问权限设置与输入输出重定向（2学时）一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限：在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作：chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限：chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行；其他用户和所属组用户只有读和执行(de)权限：chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道（1) 输出重定向用ls命令显示当前目录中(de)文件列表：ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中：ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令：cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向：ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别：cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.（2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤：在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论（根据实验结果回答下列问题）1. 文件(de)权限如下：-rw-r—r-- 1 root root 19274 Jul 14 11:00回答：-rw-r—r-- (de)含义是什么答：是LINUX/FTP(de)简易权限表示法：对应于本用户-所在组-其他人(de)权限,每一个用执行（x）-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答：chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答：chmod a+w,a+r 个人体会（你对本次实验有什么体会或看法）操作系统实验报告（三）文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令；2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题：1）vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2）在vi中退出时,保存并退出(de)操作步骤是Ese：wq3）用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令：cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4）请用至少两种不同(de)命令创建一个文本文件（）,在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________；用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限（数字和字母）分别是多少__-rw- r- - r- - 6 4 4______________.6）若将该文件(de)访问权限修改为：所有者有读写权限；其他用户只读；同组用户可读写,请写出命令,并记录结果.7）查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8）在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息；file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题：1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结（本次实验(de)体会或小结）操作系统实验报告（四）作业调度算法模拟（验证性2学时）1、实验目(de)：1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容：（1）作业调度算法（FCFS）编程模拟：编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1：FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}（2）作业调度算法（SJF）编程模拟：编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2：SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列：\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析：（对上述实验各题所使用(de)原始数据、调试数据与状态（包括出错）及最终结果进行记录并分析.）随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结：你对本次实验有什么体会或看法.。
昆明理工大学信息工程与自动化学院学生实验报告（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<<"已存在。
昆明理工大学信息工程与自动化学院学生实验报告（ 2011 —2012 学年第二学期）一、实验目的用c或c++语言编写和调试一个简单的文件系统，模拟文件管理的基本功能。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
二、实验原理及基本技术路线图（方框原理图）用c模拟实现文件系统的管理；要求设计一个多级目录结构的文件系统，能正确描述文件控制块，采用合理的外存分配方式，能实现基本的目录及文件的操作，包括创建、删除、重命名、复制、移动等功能，并对文件有一定的存取权限控制。
请加上程序功能结构图、流程图、数据结构定义、主要变量的说明、函数的说明等流程图: 主要数据结构界面采用vc6 mfc环境开发#define maxfile 20 //每个用户最多保存20个文件 #define maxuser 10 //假想文件系统最多支持的人数 #define blocksize 32 //虚拟磁盘中物理块为每块32字节#define disksize blocksize*1000 //虚拟磁盘容量为1000*32=32k struct ufd //说明文件项的结构数组 { 节};struct mfd { };struct headblock { };struct block //虚拟磁盘的物理块数据结构 { byte pstack; //堆栈指针short pblock[10]; //块号 pblock[10]是下一个盘块号逻辑地址 char username[10];//主目录用户名 bool isexist; //该用户否存在 ufd ufd[maxfile]; //用户文件数组 ushort nitem;//ufd个数 char filename[15]; char time[16]; //文件建立或修改时间如2003/5/6 12:00 bool isexist;//文件是否存在，删除时标为0bool isshared; //共享标记，共享文件可被其它用户所访问 bool attrread;//文件是否可读 bool attrwrite; //文件是否可写 bool attrexecute; //文件是否可执行htreeitem treenode; //用于树控件显示的结点句柄 ushort filelen; //文件占用字节数 ushort blocknum; //文件占用的物理块数ushort filelink[100];//文件物理块地址数组，每块32字节，限定一个文件最大100*32=3200字union{ };struct fat { };//空闲块成组链接法bool openlist[maxuser][maxfile]; //描述文件是否打开的布尔型数组 fat filefat;//描述文件记录项的fat结构cfile fatio; //负责和vdisk.dat打交道的文件句柄 cstringcurrentuser; //当前登录的用户名int currentid; //前前登录的用户标识号block superblock; //超级块，指示第一个空闲块逻辑号 ushort maxopen;//该用户同时可打开的最大文件数 ushort usernum; //最户数mfd mfd[maxuser]; //最多可支持10个用户 byte block[32]; //一块为32字节 headblock headinfo; };说明：本实验采用模拟文件结构的方法，把记录用户帐号，用户文件和磁盘块的信息用当前目录下的vdisk.dat来记录，可以把vdisk.dat看成是一个虚拟的磁盘，其头部是fat结构，用来记录各个用户和文件信息，紧接着是空闲块成组链接法的数据结构，每块32字节，每组10块，共1000块，也就是说，用户文件数据的总容量是32＊1000字节，如果程序当前目录下找不到用于做实验用的vdisk.dat,在登录时程序会提示是否“格式化虚拟磁盘”也就是新建一个vdisk.dat文件，接着，程序会显示“用户管理”的窗口，此时应新建几个帐号用于登录做实验。
操作系统文件管理系统模拟实验文件管理系统模拟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> DISK_NUM*sizeof(struct fatitem)#include<string.h> //FAT表大小#include<stdlib.h> #define ROOT_DISK_NOFATSIZE/DISKSIZE+1 #define MEM_D_SIZE 1024*1024 //根目录起始盘块号//总磁盘空间为1M #define ROOT_DISK_SIZE #define DISKSIZE 1024sizeof(struct direct) //根//磁盘块的大小1K 目录大小#define DISK_NUM 1024 #define DIR_MAXSIZE 1024//磁盘块数目1K //路径最大长度为1KB #define FATSIZE #define MSD 5 //最大子目录数5 }openitem[MOFN]; #define MOFN 5 int cur_size; /*当前打文件的//最大文件深度为5 数目*/#define MAX_WRITE 1024*128 };//最大写入文字长度128KBstruct fatitem *fat; /*FAT表*/ struct fatitem /* size 8*/ struct direct *root; /*根目录*/ { struct direct *cur_dir; /*当前int item; /*存放文件下一个磁目录*/盘的指针*/ struct opentable u_opentable; /*char em_disk; /*磁盘块是否空闲文件打开表*/标志位 0 空闲*/ int fd=-1; /*文件打开表的序}; 号*/char *bufferdir; /*记录当前路struct direct 径的名称*/{ char *fdisk; /*虚拟磁盘起始地/*-----文件控制快信息-----*/ 址*/struct FCB{ void initfile();char name[9]; /*文件/目录void format();8位*/ void enter(); 名char property; /*属性 1位void halt(); 目录 0位普通文件*/ int create(char *name);int size; /*文件/目录字int open(char *name); 节数、盘块数)*/ int close(char *name);int firstdisk; /*文件/目int write(int fd,char *buf,int 录起始盘块号*/ len);int next; /*子目录起始盘int read(int fd,char *buf); 块号*/ intdel(char *name);int sign; /*1是根目录 0int mkdir(char *name); 不是根目录*/ int rmdir(char *name);void dir();}directitem[MSD+2]; int cd(char *name);void print();}; void show();struct opentable void initfile() { {struct openttableitem fdisk = (char{ *)malloc(MEM_D_SIZE*sizeof(char)char name[9]; /*文件名*/ ); /*申请 1M空间*/int firstdisk; /*起始盘块 format();号*/int size; /*文件的大小*/ }me,".");void format() root->directitem[0].next = { root->directitem[0].firstdisk;int i; root->directitem[0].propertyFILE *fp; = '1';root->directitem[0].size =fat = (struct fatitem ROOT_DISK_SIZE;*)(fdisk+DISKSIZE); /*计算FAT表-------指向上一级目录的目录 /*地址，引导区向后偏移 1k)*/ 项---------*//*-----初始化FAT表 root->directitem[1].sign = 1; ------------*/ root->directitem[1].firstdiskfat[0].item=-1; /*引导块*/ = ROOT_DISK_NO;fat[0].em_disk='1'; strcpy(root->directitem[1].name,"..");for(i=1;i<ROOT_DISK_NO-1;i++) root->directitem[1].next = /*存放 FAT 表的磁盘块号*/ root->directitem[0].firstdisk;{ root->directitem[1].propertyfat[i].item=i+1; = '1';fat[i].em_disk='1'; root->directitem[1].size =} ROOT_DISK_SIZE;if((fp =fat[ROOT_DISK_NO].item=-1; fopen("disk.dat","wb"))==NULL) /*存放根目录的磁盘块号*/ {fat[ROOT_DISK_NO].em_disk='1' printf("Error:\n Cannot ; open file \n");return;for(i=ROOT_DISK_NO+1;i<DISK_N }UM;i++) for(i=2;i<MSD+2;i++) /*-子目{ 录初始化为空-*/fat[i].item = -1; {fat[i].em_disk = '0'; root->directitem[i].sign =} 0;/*-----------------------------------------------*/ root->directitem[i].firstdiskroot = (struct direct = -1;*)(fdisk+DISKSIZE+FATSIZE); /*根目录的地址*/ strcpy(root->directitem[i].na/*初始化目录*/ me,"");/*---------指向当前目录的目录 root->directitem[i].next = 项---------*/ -1;root->directitem[0].sign = 1;root->directitem[0].firstdisk root->directitem[i].property =ROOT_DISK_NO; = '0';strcpy(root->directitem[0].na root->directitem[i].size =0; }} fat = (struct fatitem*)(fdisk+DISKSIZE); /*找到FAT表地址*/root = (struct direct if((fp =fopen("disk.dat","wb"))==NULL) *)(fdisk+DISKSIZE+FATSIZE);/*找{ 到根目录地址*/printf("Error:\n Cannot fclose(fp);open file \n"); /*--------------初始化用户打return; 开表------------------*/} for(i=0;i<MOFN;i++)if(fwrite(fdisk,MEM_D_SIZE,1, {fp)!=1) /*把虚拟磁盘空间保存到磁盘文件中*/ strcpy(u_opentable.openitem[i{ ].name,"");printf("Error:\n Fileu_opentable.openitem[i].firstwrite error! \n");disk = -1; }fclose(fp); u_opentable.openitem[i].size= 0; } }void enter() u_opentable.cur_size = 0; {FILE *fp; cur_dir = root; /*当前目录为根int i; 目录*/bufferdir = (charfdisk = (char*)malloc(DIR_MAXSIZE*sizeof(char*)malloc(MEM_D_SIZE*sizeof(char)));); /*申请 1M空间*/ strcpy(bufferdir,"Root:");if((fp=fopen("disk.dat","rb")})==NULL){ void halt()printf("Error:\nCannot {open file\n"); FILE *fp;return; int i;}if(!fread(fdisk,MEM_D_SIZE,1, if((fp=fopen("disk.dat","wb")fp)) /*把磁盘文件disk.dat 读入)==NULL)虚拟磁盘空间(内存)*/ {{ printf("Error:\nCannotprintf("Error:\nCannot open file\n");read file\n"); return;exit(0); }if(!fwrite(fdisk,MEM_D_SIZE,1 return(-2);,fp)) /*把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat */ if(u_opentable.cur_size>=MOFN) /*{ 打开文件太多*/printf("Error:\nFile write return(-3);error!\n");}fclose(fp);for(j=ROOT_DISK_NO+1;j<DISK_NUM;free(fdisk); j++) /*找到空闲盘块 j 后退出*/free(bufferdir); {return; if(fat[j].em_disk=='0') } break;}int create(char *name) if(j>=DISK_NUM){ return(-5);fat[j].em_disk = '1'; /*将空int i,j; 闲块置为已经分配*//*-----------填写目录项if(strlen(name)>8) /*文件名大-----------------*/于 8位*/return(-1); strcpy(cur_dir->directitem[i].name,name);for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/ cur_dir->directitem[i].firstdisk{ = j;cur_dir->directitem[i].size =if(!strcmp(cur_dir->directite0;m[j].name,name)) cur_dir->directitem[i].next =break; j;}if(j<MSD+2) /*文件已经存cur_dir->directitem[i].property = 在*/ '0'; return(-4);/*------------------------------for(i=2;i<MSD+2;i++) /*找到第---*/一个空闲子目录*/ fd = open(name);{ return 0;if(cur_dir->directitem[i].fir}stdisk==-1)break; int open(char *name)} {if(i>=MSD+2) /*无空目录项*/ int i, j;/*--------------填写表项的相for(i=2;i<MSD+2;i++) /*文件是关信息------------------------*/ 否存在*/{ u_opentable.openitem[j].firstdisk =if(!strcmp(cur_dir->directitecur_dir->directitem[i].firstdiskm[i].name,name)) ;break;} strcpy(u_opentable.openitem[j].nif(i>=MSD+2) ame,name);return(-1); u_opentable.openitem[j].size/*--------是文件还是目录= cur_dir->directitem[i].size; -----------------------*/ u_opentable.cur_size++;if(cur_dir->directitem[i].pro /*----------返回用户打开表表perty=='1') 项的序号return(-4); --------------------------*/return(j);件是否打开 /*--------文}-----------------------*/for(j=0;j<MOFN;j++) int close(char *name){ {int i;if(!strcmp(u_opentable.openitem[j].name,name)) for(i=0;i<MOFN;i++)break; {}if(j<MOFN) /*文件已经打开*/ if(!strcmp(u_opentable.openitreturn(-2); em[i].name,name))break;}if(i>=MOFN)if(u_opentable.cur_size>=MOFN) /* return(-1);文件打开太多*/ /*-----------清空该文件的用return(-3); 户打开表项的内容---------------------*//*--------查找一个空闲用户打开表项-----------------------*/ strcpy(u_opentable.openitem[i].n for(j=0;j<MOFN;j++) ame,"");{u_opentable.openitem[i].firstdisif(u_opentable.openitem[j].fik = -1;rstdisk==-1) u_opentable.openitem[i].sizebreak; = 0;} u_opentable.cur_size--;下标-*//*------找到的item 是该文件的return 0; 最后一块磁盘块} -------------------*/while(fat[item].item!=-1) int write(int fd, char *buf, int { len) item =fat[item].item; /*-*/ { 查找该文件的下一盘块--} char *first;int item, i, j, k;int ilen1, ilen2, modlen, temp; /*-----计算出该文件的最末地址/*----------用 $ 字符作为空格 -------*/# 字符作为换行符 first =-----------------------*/ fdisk+item*DISKSIZE+u_opentable. char Space = 32; openitem[fd].size%DISKSIZE;char Endter= '\n';/* -----如果最后磁盘块剩余的大for(i=0;i<len;i++) 小大于要写入的文件的大小{ -------*/if(buf[i] == '$') if(DISKSIZE-u_opentable.openibuf[i] = Space; tem[fd].size%DISKSIZE>len)else if(buf[i] == '#') {buf[i] = Endter; strcpy(first,buf);}u_opentable.openitem[fd].size/*----------读取用户打开表对=应表项第一个盘块号u_opentable.openitem[fd].size+le-----------------------*/ n;item = cur_dir->directitem[temp].sizu_opentable.openitem[fd].firstdie = sk; cur_dir->directitem[temp].size+len;/*-------------找到当前目录所 }对应表项的序号 else-------------------------*/ {for(i=2;i<MSD+2;i++){ for(i=0;i<(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);iif(cur_dir->directitem[i].fir++)stdisk==item) {/*写一部分内容到最后一块break; 磁盘块的剩余空间(字节)*/} first[i] = buf [i];temp = i; /*-存放当前目录项的 }/*-----计算分配完最后一块=buf[k];磁盘的剩余空间(字节) 还剩下多少 }字节未存储-------*/ilen1 = fat[item].item = i; len-(DISKSIZE-u_opentable.openit--找到一块后将它的序号存放在上/*em[fd].size%DISKSIZE); 一块的指针中-*/ilen2 = ilen1/DISKSIZE; fat[i].em_disk = '1';modlen = ilen1%DISKSIZE; --置找到的磁盘快的空闲标志位为/*if(modlen>0) 已分配-*/ilen2 = ilen2+1; /*-- fat[i].item = -1; /*--还需要多少块磁盘块-*/ 它的指针为 -1 (即没有下一块)-*/}for(j=0;j<ilen2;j++) /*--修改长度-*/{u_opentable.openitem[fd].sizefor(i=ROOT_DISK_NO+1;i<DISK_N=UM;i++)/*寻找空闲磁盘块*/ u_opentable.openitem[fd].size+len; {cur_dir->directitem[temp].siz if(fat[i].em_disk=='0')break; e =} cur_dir->directitem[temp].size+lif(i>=DISK_NUM) /*--如en;果磁盘块已经分配完了-*/ }return(-1); return 0;first = }fdisk+i*DISKSIZE; /*--找到的那块空闲磁盘块的起始地址-*/ int read(int fd, char *buf)if(j==ilen2-1) /*--如{果是最后要分配的一块-*/ int len ={ u_opentable.openitem[fd].size;char *first;for(k=0;k<len-(DISKSIZE-u_ope int i, j, item;ntable.openitem[fd].size%DISKSIZ int ilen1, modlen; E)-j*DISKSIZE;k++) first[k] = item =buf[k]; u_opentable.openitem[fd].firstdi} sk;else/*-如果不是要最后分配的一块--*/{ ilen1 = len/DISKSIZE;modlen = len%DISKSIZE;for(k=0;k<DISKSIZE;k++) if(modlen!=0)first[k] ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/ 项的序号,供释放目录中-*/first = fdisk+item*DISKSIZE; if(i>=MSD+2) /*--如果不在当前/*--计算文件的起始位置-*/ 目录中-*/return(-1);for(i=0;i<ilen1;i++){ if(cur_dir->directitem[cur_itif(i==ilen1-1) /*--如果在em].property!='0') /*--如果删除的最后一个磁盘块-*/ (不)是目录-*/{ return(-3);for(j=0;j<len-i*DISKSIZE;j++) for(i=0;i<MOFN;i++) /*--如果buf[i*DISKSIZE+j] = 文件打开,则不能删除,退出-*/first[j]; {}else /*--不在最后一块磁盘 if(!strcmp(u_opentable.openit块-*/ em[i].name,name)){ return(-2);}for(j=0;j<len-i*DISKSIZE;j++) item =cur_dir->directitem[cur_item].fi buf[i*DISKSIZE+j] =first[j]; rstdisk;/*--该文件的起始盘块号item = fat[item].item; -*//*-查找下一盘块-*/ while(item!=-1) /*--释放空间,first = 将FAT表对应项进行修改-*/fdisk+item*DISKSIZE; {} temp = fat[item].item;} fat[item].item = -1;return 0; fat[item].em_disk = '0'; } item = temp;}int del(char *name) /*-----------------释放目录项{ -----------------------*/int i,cur_item,item,temp; cur_dir->directitem[cur_item].sign = 0;for(i=2;i<MSD+2;i++) /*--查找 cur_dir->directitem[cur_item]要删除文件是否在当前目录中-*/ .firstdisk = -1;{ strcpy(u_opentable.openitem[cur_item].name,"");if(!strcmp(cur_dir->directitem[i].name,name)) cur_dir->directitem[cur_item].nebreak; xt = -1;}cur_item = i; /*--用来保存目录cur_dir->directitem[cur_item].pr operty = '0'; {cur_dir->directitem[cur_item] if(fat[j].em_disk=='0') .size = 0; break;}if(j>=DISK_NUM) return 0;} return(-5);fat[j].em_disk='1'; /*-将该空int mkdir(char *name) 闲块设置为已分配-*/{int i,j; /*-------------填写目录项struct direct *cur_mkdir; ----------*/strcpy(cur_dir->directitem[i]if(!strcmp(name,".")) .name,name);return(-4); cur_dir->directitem[i].firstdif(!strcmp(name,"..")) isk=j;return(-4); cur_dir->directitem[i].size=Rif(strlen(name)>8) /*-如果目OOT_DISK_SIZE;8位-*/ 录名长度大于 cur_dir->directitem[i].next=jreturn(-1); ;cur_dir->directitem[i].properfor(i=2;i<MSD+2;i++) /*-如果ty='1';有空闲目录项退出-*/{/*-所创目录在虚拟磁盘上的地址if(cur_dir->directitem[i].fir(内存物理地址)-*/stdisk==-1) cur_mkdir=(struct directbreak; *)(fdisk+cur_dir->directitem[i].} firstdisk*DISKSIZE);if(i>=MSD+2) /*-目录/文件已满-*/ /*-初始化目录-*/return(-2); /*-指向当前目录的目录项-*/for(j=2;j<MSD+2;j++) /*-判断 cur_mkdir->directitem[0].sign是否有重名-*/ =0;{ cur_mkdir->directitem[0].firstdisk=cur_dir->directitem[i].firif(!strcmp(cur_dir->directitestdisk;m[j].name,name)) strcpy(cur_mkdir->directitem[break; 0].name,".");} cur_mkdir->directitem[0].nextif(j<MSD+2) /*-如果有重名-*/ =cur_mkdir->directitem[0].firstdreturn(-3); isk;for(j=ROOT_DISK_NO+1;j<DISK_N cur_mkdir->directitem[0].propUM;j++) /*-找到空闲磁盘块 j 后退erty='1';出-*/ cur_mkdir->directitem[0].size=ROOT_DISK_SIZE; int i,j,item;struct direct *temp_dir;/*-指向上一级目录的目录项-*/ /*-检查当前目录项中有无该目录cur_mkdir->directitem[1].sign-*/=cur_dir->directitem[0].sign; for(i=2;i<MSD+2;i++)cur_mkdir->directitem[1].firs {tdisk=cur_dir->directitem[0].firstdisk; if(!strcmp(cur_dir->directitestrcpy(cur_mkdir->directitem[m[i].name,name))1].name,".."); break;cur_mkdir->directitem[1].next }=cur_mkdir->directitem[1].firstd if(i>=MSD+2) /*-没有这个文件isk; 或目录-*/cur_mkdir->directitem[1].prop return(-1);erty='1'; if(cur_dir->directitem[i].procur_mkdir->directitem[1].sizeperty!='1')/*-删除的不是目录-*/=ROOT_DISK_SIZE; return(-3);for(i=2;i<MSD+2;i++) /*-子目录都初始化为空-*/ /*-判断要删除的目录有无子目录{ -*/cur_mkdir->directitem[i].sign temp_dir=(struct direct =0;*)(fdisk+cur_dir->directitem[i].next*DISKSIZE);cur_mkdir->directitem[i].firs for(j=2;j<MSD+2;j++) tdisk=-1; { strcpy(cur_mkdir->directitem[ if(temp_dir->directitem[j].nei].name,""); xt!=-1)break;cur_mkdir->directitem[i].next }=-1; if(j<MSD+2) /*-有子目录或文件-*/cur_mkdir->directitem[i].prop return(-2);erty='0'; /*------------找到起始盘块号,并将其释放----------------*/cur_mkdir->directitem[i].size item=cur_dir->directitem[i].f=0; irstdisk;} fat[item].em_disk='0';return 0; /*-修改目录项-*/} cur_dir->directitem[i].sign=0;int rmdir(char *name) cur_dir->directitem[i].firstd{ isk=-1;strcpy(cur_dir->directitem[i] str=name;.name,"");cur_dir->directitem[i].next=- if(!strcmp("\\",name)) 1; {cur_dir->directitem[i].proper cur_dir = root; ty='0';cur_dir->directitem[i].size=0 strcpy(bufferdir,"Root:"); ; return 0;}return 0;} temp = (char*)malloc(DIR_MAXSIZE*sizeof(charvoid dir() ));/*-最长路径名字分配空间-*/ {int i; for(i=0;i<(int)strlen(str);i+for(i=2;i<MSD+2;i++) +){ temp[i]=str[i];temp[i]='\0';if(cur_dir->directitem[i].firfor(j=0;j<MSD+2;j++) /*-查找stdisk!=-1) /*-如果存在子目录-*/该子目录是否在当前目录中-*/ {{printf("%s\t",cur_dir->directitem[i].name); if(!strcmp(temp_dir->directitem[j].name,temp))if(cur_dir->directitem[i].pro break;perty=='0') /*-文件-*/ }printf("%d\t\t\n",cur_dir->di free(temp);/*释放申请的临时空rectitem[i].size); 间*/else //if(temp_dir->directitem[j].printf("\t<目property!='1') /*-打开的不是目录录>\t\n"); -*/} //return(-2);} if(j>=MSD+2) /*-不在当前目录} -*/return(-1);int cd(char *name){ item=temp_dir->directitem[j].int i,j,item; firstdisk;char *str; /*-当前目录在磁盘中位置-*/char *temp,*point,*point1; temp_dir=(struct directstruct direct *temp_dir; *)(fdisk+item*DISKSIZE);temp_dir=cur_dir;}if(!strcmp("..",name)){ void print(){if(cur_dir->directitem[j-1].s printf("*********************ign!=1) /*-如果上级目录不是根目录******************************** -*/ ****\n");printf("********************* {*文件系统设计point=strchr(bufferdir,'\\'); ***********************\n");//查找字符串bufferdir中首次出现 printf("*\t命令格式说明字符\ 的位置 *\n");printf("*\tcd 目录名更改while(point!=NULL) 当前目录 *\n");{ printf("*\tmkdir 目录名point1=point+1; /*- 创建子目录 *\n"); 减去'\'所占的空间,记录下次查找的 printf("*\trmdir 目录名*/ \n"); 起始地址- 删除子目录 *printf("*\tdir 显示point=strchr(point1,'\\当前目录的子目录 *'); \n");文件名 } printf("*\tcreate*(point1-1)='\0'; /*- 创建文件 *\n"); 将上一级目录删除-*/printf("*\tdel 文件名} 删除文件 *\n");printf("*\topen 文件名} 打开文件 *\n");printf("*\tclose 文件名else 关闭文件 *\n");{ printf("*\tread 读文//if(name[0] !='\\') 件 *\n");bufferdir = printf("*\twrite 写文strcat(bufferdir,"\\"); /*-修改当件*\n"); 前目录-*/ printf("*\texit 退出bufferdir = 系统 *\n"); strcat(bufferdir,name);printf("*********************} ********************************cur_dir=temp_dir; /*-将当前****\n"); 目录确定下来-*/return 0; }}void main() void show() {{ FILE *fp;printf("%s>",bufferdir); char ch;char a[100];char code[11][10]; while(1)char name[10]; {int i,flag,r_size; scanf("%s",a);char *contect; for(i=0;i<11;i++){contect = (char if(!strcmp(code[i],a))*)malloc(MAX_WRITE*sizeof(char)) break;} ;if((fp=fopen("disk.dat","rb") switch(i))==NULL) {{ case 0: //退出文件系统printf("You have not free(contect); format,Do you want format?(y/n)"); halt();return; scanf("%c",&ch);case 1: //创建文件if(ch=='y') scanf("%s",name);{ flag = create(name);initfile(); if(flag==-1)printf("Successfully {format! \n"); printf("Error: \n} The length is too long !\n");else }{ else if(flag==-2)return; {} printf("Error: \n} The direct item is alreadyfull !\n");enter(); }print(); else if(flag==-3)show(); {printf("Error: \nstrcpy(code[0],"exit"); The number of openfile is too strcpy(code[1],"create"); much !\n");strcpy(code[2],"open"); }strcpy(code[3],"close"); else if(flag==-4)strcpy(code[4],"write"); {strcpy(code[5],"read"); printf("Error: \nstrcpy(code[6],"del"); The name is already in the strcpy(code[7],"mkdir"); direct !\n");strcpy(code[8],"rmdir"); }strcpy(code[9],"dir"); else if(flag==-5)strcpy(code[10],"cd"); {printf("Error: \n show();The disk space is full!\n"); break;}else case 3://关闭文件scanf("%s",name); {flag = close(name);printf("Successfully create a if(flag == -1) { file! \n");} printf("Error:\nThe file is not opened ! \n");show(); }break; else{case 2://打开文件scanf("%s",name); printf("Successfully closed! fd = open(name); \n");if(fd == -1) }{ show();printf("Error: \n break;The open file not exit! \n");case 4://写文件 }else if(fd == -2) if(fd ==-1){ {printf("Error: \n printf("Error:\n The file have already opened!\n"); The file is not opened ! \n");} }else if(fd == -3) else{ {printf("Error: \n printf("Please The number of open file is too much! input the file contect:"); \n");} scanf("%s",contect);else if(fd == -4){ flag=write(fd,contect,strlen(printf("Error: \n contect));It is a direct,can not open for read if(flag == 0) or write! \n"); { }else printf("Successfully write!{ \n");}printf("Successfully opened! else\n"); {}printf("Error:\n The disk size close it ! \n"); is not enough!\n"); }} else if(flag == -3)} {show(); printf("Error:\nbreak; The delete is not file ! \n");}case 5://读文件 elseif(fd ==-1) {{printf("Error:\n printf("Successfully delete! The file is not opened ! \n"); \n");} }else show();{ break;flag =read(fd,contect); case 7://创建子目录if(flag == 0) scanf("%s",name);{ flag = mkdir(name);if(flag == -1)for(i=0;i<u_opentable.openite {m[fd].size;i++) printf("Error:\n{ The length of name is to long! \n");}printf("%c",contect[i]); else if(flag == -2)} {printf("\t\n"); printf("Error:\n} The direct item is already full !} \n");show(); }break; else if(flag == -3){case 6://删除文件 printf("Error:\nscanf("%s",name); The name is already in the direct !flag = del(name); \n");if(flag == -1) }{ else if(flag == -4)printf("Error:\n {The file not exit! \n"); printf("Error: \n} '..' or '.' can not as the name ofelse if(flag == -2) the direct!\n");{ }printf("Error:\n else if(flag == -5) The file is opened,please first {printf("Error: \n }The disk space is full!\n"); show();} break;else if(flag == 0)case 9://显示当前子目录 {dir();printf("Successfully make show();break; dircet! \n");}show(); case 10://更改当前目录break; scanf("%s",name);flag = cd(name);case 8://删除子目录 if(flag == -1)scanf("%s",name); {flag = rmdir(name); printf("Error:\nif(flag == -1) The path no correct!\n");{ }printf("Error:\n else if(flag == -2) The direct is not exist! \n"); {}else if(flag == -2) printf("Error:\nThe opened is{ not direct!\n");}printf("Error:\nThe direct hasson direct ,please first remove the show();son dircct!\n"); break;}else if(flag == -3) default:{ printf("\n Error!\n Theprintf("Error:\n command is wrong! \n"); The remove is not direct ! \n"); show();}else if(flag == 0) }{ }}printf("Successfully removedircet! \n");5.程序运行截图6.实验总结通过这一次计算机操作系统的上机实验，使我对不同环境下的操作系统有了进一步的了解，使我学到了很多关于Linux的操作和相关知识。
