下载文档原格式
操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件，它管理着计算机的硬件资源和软件资源，为用户提供了一个方便、高效、稳定的工作环境。
本次操作系统实验的目的在于通过实际操作和实践，深入理解操作系统的基本原理和核心概念，掌握操作系统的基本功能和操作方法，提高对操作系统的认识和应用能力。
二、实验环境本次实验使用的操作系统为 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.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
操作系统文件管理系统模拟实验文件管理系统模拟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的操作和相关知识。
