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

合集下载

操作系统实验实验报告

操作系统实验实验报告

操作系统实验实验报告一、实验目的操作系统是计算机系统中最为关键的核心软件,它管理着计算机的硬件资源和软件资源,为用户提供了一个方便、高效、稳定的工作环境。

本次操作系统实验的目的在于通过实际操作和实践,深入理解操作系统的基本原理和核心概念,掌握操作系统的基本功能和操作方法,提高对操作系统的认识和应用能力。

二、实验环境本次实验使用的操作系统为 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、进行文件操作和目录操作。

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

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

操作系统Lab2实验报告

操作系统Lab2实验报告

深入学习 操作系统的原理和实 现细节,包括进程通 信、死锁处理、虚拟 化技术等。
实践应用
希望将所学的操作系 统知识应用到实际项 目中,提高自己的实 践能力。
持续学习
随着技术的不断发展 ,操作系统也在不断 更新和进步,需要保 持持续学习的态度。
探索新领域
对于新兴的操作系统 领域,如云操作系统 、物联网操作系统等 ,也希望有所涉猎和 探索。
学生将了解操作系统内核的组成和功能,以及操作系统如何通过内核 实现各种基本功能。
学生将通过实验深入了解操作系统的内部实现细节,提高自己对操作 系统设计和实现的认知水平。
02
实验内容
进程管理实验
总结词
理解进程状态及其转换、进程控制块PCB的组成、进程调度算法。
详细描述
通过实验,我们深入了解了进程的概念、状态及其转换。进程控制块PCB的组成,包括进程标 识符、进程状态、优先级、CPU寄存器内容等信息。此外,我们还学习了进程调度算法,如先 来先服务、最短作业优先、优先级调度等,并进行了模拟实验。
THANKS
感谢观看
操作系统Lab2实验 报告
汇报人:
202X-01-08
目录
• 实验目的 • 实验内容 • 实验结果与分析 • 问题与改进建议 • 总结与展望
01
实验目的
理解操作系统的基本概念
01
掌握核心概念
02
操作系统是计算机系统的核心软件,负责管理计算机硬件和软件资源 ,为用户提供便利的操作界面和高效的服务。
03
操作系统具有并发性、虚拟性、异步性和随机性的特点,这些特点决 定了操作系统在计算机系统中的重要地位和作用。
04
操作系统的基本功能包括进程管理、内存管理、文件管理和设备管理 ,这些功能是操作系统实现其核心目标的基础。

操作系统教学实践(3篇)

操作系统教学实践(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 系统使用实验报告一、实验目的本次实验旨在深入了解和熟悉 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. 文件的共享和保护机制在摹拟文件管理系统中,多个进程可以同时对同一个文件进行读写操作。

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

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

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

操作系统实验报告三

操作系统实验报告三

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

操作系统实验

操作系统实验

操作系统实验报告(一)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<<"已存在。

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

《操作系统》模拟实验系统的设计与实现
为平 台的实验系统 ,学生在学习课程原理 的基础上 ,借 助 于I D E 可视化环境打开模拟系 统的代码 ,进行算法 的 修改 、补充等操作 ,通过实验结果深入分析模 拟操作系
/ / 进程的优先级
P MMP AS Pa s ;
/ / 进 程地 址 空 间 L O NG c o u n t e r ; / / 进 程 已运 行 时 间
关 键 词 :操 作 系统 ; 实验 ;进 程 ; 内存
据l i n u x 0 . 1 1 的结构 ,模拟O S 十分小巧 ,结构清晰 ,但仍
引 言
《 操作 系统 》是计 算机相关 专业 的一 门专业 基础
课 ,该课程概ቤተ መጻሕፍቲ ባይዱ多 、较抽象 ,学生理解 困难 ,单独讲授
然涵盖 了进程管理 、内存管理 、文件管理等操作 系统功
统 的架构和源代码 ,充分激发学生的兴趣和主动性 ,从 而加深 学生对操作 系统原理 的理解 ,提高动手 实践能 力。每个实验代码 中都 留有一些接 口,学生可根据算法 原理编写代码 ,需要 补充的代码一般在5 0 行左右。

L O NG p r i o r i y t
/ / 进程优先级
统 ,该系统是在麻省理工学院开放 的课程平 台下 自主开 发 的实验系统 :T i n g H u a O p e r a t i n g S y s t e m P r o j e c t 。
p r o c e s s . h 是负责进程 管理 的头文件 ,将 进程控制块 和记 录型信号量声 明为结构体类 型 ,P C B中记录了进程 的基本情况及对 于进程控制 的全部信息 。当操作 系统创
/ /文
L0N G Co u n t :

文件实验报告

文件实验报告

昆明理工大学信息工程与自动化学院学生实验报告( 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文件,接着,程序会显示“用户管理”的窗口,此时应新建几个帐号用于登录做实验。

操作系统课程实验报告

操作系统课程实验报告

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

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

二、实验环境本次实验使用的操作系统为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()函数终止指定进程。

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

文件管理系统模拟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 FATSIZEDISK_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_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].first disk = ROOT_DISK_NO;strcpy(root->directitem[0 ].name,".");root->directitem[0].next = root->directitem[0].firstdisk;root->directitem[0].prope rty = '1';root->directitem[0].size = ROOT_DISK_SIZE;/*-------指向上一级目录的目录项---------*/root->directitem[1].sign = 1;root->directitem[1].first disk = ROOT_DISK_NO;strcpy(root->directitem[1 ].name,"..");root->directitem[1].next = root->directitem[0].firstdisk;root->directitem[1].prope rty = '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:\nCannot 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:\nCannotopen file\n");return;}if(!fread(fdisk,MEM_D_SIZE,1,fp)) /*把磁盘文件disk.dat读入虚拟磁盘空间(内存)*/{printf("Error:\nCannotread 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].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"))==NULL) { printf("Error:\nCannot open file\n"); return; } if(!fwrite(fdisk,MEM_D_SI ZE,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->directitem[i].name,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.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].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].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.o penitem[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].siz e = 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].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_item].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_i tem].sign = 0;cur_dir->directitem[cur_i tem].firstdisk = -1;strcpy(u_opentable.openit em[cur_item].name,"");cur_dir->directitem[cur_item].next = -1;cur_dir->directitem[cur_item].pr operty = '0';cur_dir->directitem[cur_i tem].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<DI SK_NUM;j++) /*-找到空闲磁盘块 j 后退出-*/{if(fat[j].em_disk=='0')break;}if(j>=DISK_NUM)return(-5);fat[j].em_disk='1'; /*-将该空闲块设置为已分配-*//*-------------填写目录项----------*/strcpy(cur_dir->directite m[i].name,name);cur_dir->directitem[i].fi rstdisk=j;cur_dir->directitem[i].size=ROOT_DISK_SIZE;cur_dir->directitem[i].ne xt=j;cur_dir->directitem[i].pr operty='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->directi tem[0].name,".");cur_mkdir->directitem[0]. next=cur_mkdir->directitem[0].fi rstdisk;cur_mkdir->directitem[0]. property='1';cur_mkdir->directitem[0]. size=ROOT_DISK_SIZE;/*-指向上一级目录的目录项-*/cur_mkdir->directitem[1]. sign=cur_dir->directitem[0].sign ;cur_mkdir->directitem[1]. firstdisk=cur_dir->directitem[0] .firstdisk;strcpy(cur_mkdir->directi tem[1].name,"..");cur_mkdir->directitem[1]. next=cur_mkdir->directitem[1].fi rstdisk;cur_mkdir->directitem[1]. property='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] .property!='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].firstdisk;fat[item].em_disk='0';/*-修改目录项-*/cur_dir->directitem[i].si gn=0;cur_dir->directitem[i].fi rstdisk=-1;strcpy(cur_dir->directite m[i].name,"");cur_dir->directitem[i].ne xt=-1;cur_dir->directitem[i].pr operty='0';cur_dir->directitem[i].si ze=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.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 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的操作和相关知识。

相关文档
最新文档