操作系统实验全(五个)
操作系统试验指导
—. 课程的性质、目的和任务
操作系统在整个计算机系统软件中占有中心地位。其作用是对计算机系统进行统一的调度和管理，提供各种强有力的系统服务，为用户创造既灵活又方便的使用环境。本课程是计算机及应用专业的一门专业主干课和必修课。通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。
二. 实验的意义和目的
操作系统是计算机专业学生的一门重要的专业课程。操作系统质量对整个计算机系统的性能和用户对计算机的使用有重大的影响。一个优良的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。
三.实验运行环境及上机前的准备
实验运行环境: C语言编程环境
上机前的准备工作包括：
●按实验指导书要求事先编好程序；
●准备好需要输入的中间数据；
●估计可能出现的问题；
●预计可能得到的运行结果。
四. 实验内容及安排
实验内容包括进程调度、银行家算法、页式地址重定位模拟，LRU算法模拟和先来先服务算法五个实验。每个实验介绍了实习的目的要求、内容和方法。
实验一、进程调度试验
[目的要求]
用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的
理解．
[准备知识]
一、基本概念
1、进程的概念；
2、进程的状态和进程控制块；
3、进程调度算法；
二、进程调度
1、进程的状态
2、进程的结构——PCB
进程都是由一系列操作(动作)所组成，通过这些操作来完成其任务。因此，不同的进
程，其内部操作也不相同。在操作系统中，描述一个进程除了需要程序和私有数据之外，
最主要的是需要一个与动态过程相联系的数据结构，该数据结构用来描述进程的外部特性
(名字、状态等)以及与其它进程的联系(通信关系)等信息，该数据结构称为进程控制块
(PCB ，Process Control Block)。
进程控制块PCB 与进程一一对应，PCB 中记录了系统所需的全部信息、用于描述进
程情况所需的全部信息和控制进程运行所需的全部信息。因此，系统可以通过进程的PCB
来对进程进行管理。
[试验内容]
设计一个有 N 个进程共行的进程调度程序。
进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进
程）和先来先服务算法。每个进程有一个进程控制块（ PCB ）表示。进程控制块可以包
含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU 时间、进程状态等
等。进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程
的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状
态可以是就绪 W （Wait ）、运行R （Run ）、或完成F （Finish ）三种状态之一。就绪进程
获得 CPU 后都只能运行一个时间片。用已占用CPU 时间加1来表示。如果运行一个时
间片后，进程的已占用 CPU 时间已达到所需要的运行时间，则撤消该进程，如果运行一
I/O
某事件被解除（I/O 完成）
理机分配给进程
个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。重复以上过程，直到所要进程都完成为止。
调度算法的流程图如下:
进程调度源程序如下：
jingchendiaodu.cpp
#include "stdio.h"
#include
#include
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
sort() /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ {
p->link=ready;
ready=p;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
input() /* 建立进程控制块函数*/
{
int i,num;
clrscr(); /*清屏*/
printf("\n 请输入进程号?");
scanf("%d",&num);
for(i=0;i printf("\n 进程号No.%d:\n",i); p=getpch(PCB); printf("\n 输入进程名:"); scanf("%s",p->name); printf("\n 输入进程优先数:"); scanf("%d",&p->super); printf("\n 输入进程运行时间:"); scanf("%d",&p->ntime); printf("\n"); p->rtime=0;p->state='w'; p->link=NULL; sort(); /* 调用sort函数*/ } } int space() { int l=0; PCB* pr=ready; while(pr!=NULL) { l++; pr=pr->link; } return(l); } disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ { printf("\n qname \t state \t super \t ndtime \t runtime \n"); printf("|%s\t",pr->name); printf("|%c\t",pr->state); printf("|%d\t",pr->super); printf("|%d\t",pr->ntime); printf("|%d\t",pr->rtime); printf("\n"); } check() /* 建立进程查看函数*/ { PCB* pr; printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/ disp(p); pr=ready; printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/ while(pr!=NULL) disp(pr); pr=pr->link; } } destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ { printf("\n 进程[%s] 已完成.\n",p->name); free(p); } running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ { (p->rtime)++; if(p->rtime==p->ntime) destroy(); /* 调用destroy函数*/ else { (p->super)--; p->state='w'; sort(); /*调用sort函数*/ } } main() /*主函数*/ { int len,h=0; char ch; input(); len=space(); while((len!=0)&&(ready!=NULL)) { ch=getchar(); h++; printf("\n The execute number:%d \n",h); p=ready; ready=p->link; p->link=NULL; p->state='R'; check(); running(); printf("\n 按任一键继续......"); ch=getchar(); } printf("\n\n 进程已经完成.\n"); ch=getchar(); } 实验二、银行家算法 （一）目的和要求 银行家算法是由Dijkstra设计的最具有代表性的避免死锁的算法。本实验要求用高级语言编写一个银行家的模拟算法。通过本实验可以对预防死锁和银行家算法有更深刻的认识。 （二）实验内容 1、设置数据结构 包括可利用资源向量（Availiable）,最大需求矩阵（Max）,分配矩阵（Allocation）,需求矩阵（Need） 2、设计安全性算法 设置工作向量Work 表示系统可提供进程继续运行可利用资源数目，Finish 表示系统是否有足够的资源分配给进程 （三）实验环境 1、pc 2、vc++ （四）、程序源代码： /*子函数声明*/ int Isprocessallover(); //判断系统中的进程是否全部运行完毕 void Systemstatus(); //显示当前系统中的资源及进程情况 int Banker(int ,int *); //银行家算法 void Allow(int ,int *); //若进程申请不导致死锁，用此函数分配资源 void Forbidenseason(int ); //若发生死锁，则显示原因 /*全局变量*/ int Availiable[3]={3,3,2}; //初始状态，系统可用资源量 int Max[5][3]={{7,5,3},{3,2,2},{9,0,2},{2,2,2},{4,3,3}}; //各进程对各资源的最大需求量 int Allocation[5][3]={{0,1,0},{2,0,0},{3,0,2},{2,1,1},{0,0,2}}; //初始状态，各进程占有资源量 int Need[5][3]={{7,4,3},{1,2,2},{6,0,0},{0,1,1},{4,3,1}}; //初始状态时，各进程运行完毕，还需要的资源量 int over[5]={0,0,0,0,0}; //标记对应进程是否得到所有资源并运行完毕 #include /*主函数*/ void main() { int process=0; //发出请求的进程 int decide=0; //银行家算法的返回值 int Request[3]={0,0,0}; //申请的资源量数组 int sourcenum=0; //申请的各资源量 /*判断系统中进程是否全部运行完毕*/ step1: if(Isprocessallover()==1) { cout<<"系统中全部进程运行完毕！"; return; } /*显示系统当前状态*/ Systemstatus(); /*人机交互界面*/ step2: cout<<"\n输入发出请求的进程（输入“0”退出系统）: "; cin>>process; if(process==0) { cout<<"放弃申请,退出系统！"; return; } if(process<1||process>5||over[process-1]==1) { cout<<"系统无此进程！\n"; goto step2; } cout<<"此进程申请各资源（A，B，C）数目：\n"; for(int h=0;h<3;h++) { cout< cin>>sourcenum; Request[h]=sourcenum; } /*用银行家算法判断是否能够进行分配*/ decide=Banker(process,Request); if (decide==0) { /*将此进程申请资源分配给它*/ Allow(process,Request); goto step1; } else { /*不能分配，显示原因*/ Forbidenseason(decide); goto step2; } } /*子函数Isprocessallover( )的实现*/ int Isprocessallover() { int processnum=0; for(int i=0;i<5;i++) { /*判断每个进程是否运行完毕*/ if(over[i]==1) processnum++; } if(processnum==5) /*系统中全部进程运行完毕*/ return 1; else return 0; } /*子函数Systemstatus( )的实现*/ void Systemstatus() { cout<<"此刻系统中存在的进程：\n"; for(int i=0;i<5;i++) { if(over[i]!=1) cout<<"P"< } cout< cout<<"此刻系统可利用资源（单位：个）：\n"; cout<<"A B C\n"; for(int a=0;a<3;a++) { cout< } cout< cout<<"此刻各进程已占有资源如下（单位：个）: \n" <<" A B C\n"; for(int b=0;b<5;b++) { if(over[b]==1) continue; cout<<"P"< for(int c=0;c<3;c++) cout< cout< } cout<<"各进程运行完毕还需各资源如下（单位：个）:\n" <<" A B C\n"; for(int f=0;f<5;f++) { if(over[f]==1) continue; cout<<"P"< for(int g=0;g<3;g++) cout< cout< } } /*子函数Banker(int ,int &)的实现*/ int Banker(int p,int *R) { int num=0; //标记各资源是否能满足各进程需要int Finish[5]={0,0,0,0,0}; //标记各进程是否安全运行完毕 int work[5]={0,0,0,0,0}; //用于安全检查 int AvailiableTest[3]; //用于试分配 int AllocationTest[5][3]; //同上 int NeedTest[5][3]; //同上 /*判断申请的资源是否大于系统可提供的资源总量*/ for(int j=0;j<3;j++) { if(*(R+j)>Availiable[j]) /*返回拒绝分配原因*/ return 1; } /*判断该进程申请资源量是否大于初始时其申明的需求量*/ for(int i=0;i<3;i++) { if(*(R+i)>Need[p-1][i]) /*返回拒绝原因*/ return 2; } /*为检查分配的各数据结构赋初值*/ for(int t=0;t<3;t++) { AvailiableTest[t]=Availiable[t]; } for(int u=0;u<5;u++) { for(int v=0;v<3;v++) { AllocationTest[u][v]=Allocation[u][v]; } } for(int w=0;w<5;w++) { for(int x=0;x<3;x++) { NeedTest[w][x]=Need[w][x]; } } /*进行试分配*/ for(int k=0;k<3;k++) //修改NeedTest[] { AvailiableTest[k]-=*(R+k); AllocationTest[p-1][k]+=*(R+k); NeedTest[p-1][k]-=*(R+k); } /*检测进程申请得到满足后，系统是否处于安全状态*/ for(int l=0;l<3;l++) { work[l]=AvailiableTest[l]; } for(int m=1;m<=5;m++) { for(int n=0;n<5;n++) { num=0; /*寻找用此刻系统中没有运行完的进程*/ if(Finish[n]==0&&over[n]!=1) { for(int p=0;p<3;p++) { if(NeedTest[n][p]<=work[p]) num++; } if(num==3) { for(int q=0;q<3;q++) { work[q]=work[q]+AllocationTest[n][q]; } Finish[n]=1; } } } } for(int r=0;r<5;r++) { if(Finish[r]==0&&over[r]!=1) /*返回拒绝分配原因*/ return 3; } return 0; } /*子函数Allow(int ,int &)的实现*/ void Allow(int p,int *R) { cout<<"可以满足申请！"; static int overnum; /*对进程所需的资源进行分配*/ for(int t=0;t<3;t++) { Availiable[t]=Availiable[t]-*(R+t); Allocation[p-1][t]=Allocation[p-1][t]+*(R+t); Need[p-1][t]=Need[p-1][t]-*(R+t); } /*分配后判断其是否运行完毕*/ overnum=0; for(int v=0;v<3;v++) { if(Need[p-1][v]==0) overnum++; } if(overnum==3) { /*此进程运行完毕，释放其占有的全部资源*/ for(int q=0;q<3;q++) Availiable[q]=Availiable[q]+Allocation[p-1][q]; /*标记该进程运行完毕*/ over[p-1]=1; cout<<"进程P"< } } /*子函数Forbidenseason(int )的实现*/ void Forbidenseason(int d) { cout<<"不能满足申请，此进程挂起，原因为：\n"; switch (d) { case 1:cout<<"申请的资源量大于系统可提供的资源量！";break; case 2:cout<<"申请的资源中有某种资源大于其声明的需求量！";break; case 3:cout<<"若满足申请，系统将进入不安全状态，可能导致死锁！"; } } 实验三、页式地址重定位模拟 一、实验目的： 1、用高级语言编写和调试模拟实现页式地址重定位。 2、加深理解页式地址重定位技术在多道程序设计中的作用和意义。 二、实验原理： 当进程在CPU上运行时，如指令中涉及逻辑地址时，操作系统自动根据页长得到页号和页内偏移，把页内偏移拷贝到物理地址寄存器，再根据页号，查页表，得到该页在内存中的块号，把块号左移页长的位数，写到物理地址寄存器。 三、实验内容： 1、设计页表结构 2、设计地址重定位算法 3、有良好的人机对话界面 四、程序源代码： #define pagesize 1024 #define pagetablelength 64 /*系统页表*/ const int pagetable[pagetablelength]={0,42,29,15,45,31,44,43, 41,28,1,30,12,24,6,32, 14,27,13,46,7,33,10,22, 40,2,51,11,39,23,49,50, 26,16,25,4,47,17,3,48, 52,36,58,35,57,34,21,63, 5,37,18,8,62,56,20,54, 60,19,38,9,61,55,59,53}; #include #include void main() { int logicaladdress=0; int pagenum=0; int w=0; cout<<"系统页号对应块号情况（页号——>块号）：\n"; for(int i=0;i<64;i++) { cout< if(i%8==7) cout< } cout< cin>>logicaladdress; pagenum=logicaladdress/pagesize; //求页号 w=logicaladdress%pagesize; //求页内偏移地址 if(pagenum>pagetablelength) //判断是否跃界 { cout<<"本次访问的地址已超出进程的地址空间，系统将产生越界中断！\n"; return; } cout<<"对应的物理地址为（十进制）：\n"< 二、程序调试： 调试数据一： 系统页号对应块号情况（页号——>块号）： 0--> 0 1-->42 2-->29 3-->15 4-->45 5-->31 6-->44 7-->43 8-->41 9-->28 10--> 1 11-->30 12-->12 13-->24 14--> 6 15-->32 16-->14 17-->27 18-->13 19-->46 20--> 7 21-->33 22-->10 23-->22 24-->40 25--> 2 26-->51 27-->11 28-->39 29-->23 30-->49 31-->50 32-->26 33-->16 34-->25 35--> 4 36-->47 37-->17 38--> 3 39-->48 40-->52 41-->36 42-->58 43-->35 44-->57 45-->34 46-->21 47-->63 48--> 5 49-->37 50-->18 51--> 8 52-->62 53-->56 54-->20 55-->54 56-->60 57-->19 58-->38 59--> 9 60-->61 61-->55 62-->59 63-->53 请输入逻辑地址（十进制）： 2500 对应的物理地址为（十进制）： 30148 Press any key to continue 调试数据二： 系统页号对应块号情况（页号——>块号）： 0--> 0 1-->42 2-->29 3-->15 4-->45 5-->31 6-->44 7-->43 8-->41 9-->28 10--> 1 11-->30 12-->12 13-->24 14--> 6 15-->32 16-->14 17-->27 18-->13 19-->46 20--> 7 21-->33 22-->10 23-->22 24-->40 25--> 2 26-->51 27-->11 28-->39 29-->23 30-->49 31-->50 32-->26 33-->16 34-->25 35--> 4 36-->47 37-->17 38--> 3 39-->48 40-->52 41-->36 42-->58 43-->35 44-->57 45-->34 46-->21 47-->63 48--> 5 49-->37 50-->18 51--> 8 52-->62 53-->56 54-->20 55-->54 56-->60 57-->19 58-->38 59--> 9 60-->61 61-->55 62-->59 63-->53 请输入逻辑地址（十进制）： 765497 本次访问的地址已超出进程的地址空间，系统将产生越界中断！ Press any key to continue 实验四、LRU算法模拟 一、实验目的和要求 用高级语言模拟页面置换算法LRU，加深对LRU算法的认识。 二、实验原理 其基本原理为：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，再最近未来是不大可能被访问的。 三、实验环境 1、pc 2、vc++ 四、程序源代码： #define MAXSIZE 20 #include void main() { int input=0; //用于输入作业号 int worknum=0; //输入的作业个数 int storesize=0; //系统分配的存储区块数 int interrupt=0; //缺页中断次数 int stack[MAXSIZE]; //栈，LRU算法的主要数据结构int workstep[MAXSIZE]; //记录作业走向 /*初始化*/ for(int i=0;i { stack[i]=0; workstep[i]=0; } cout<<"请输入存储区块数："; cin>>storesize; cout<<"请输入作业的页面走向（输入0结束）：\n"; for(int j=0;j { cout<<"页面号"< cin>>input; workstep[j]=input; if(input==0) { cout<<"输入结束！\n"; break; } worknum++; } if(workstep[0]==0) { cout<<"未输入任何作业，系统将退出！\n"; return; } cout<<"置换情况如下：\n"; for(int k=0;k { /*在栈中找相等的页号或空位置*/ for(int l=0;l { /*是否有相等的页号*/ if(stack[l]==workstep[k]) { cout<<"内存中有"< goto step1; } /*找栈中是否有空位置*/ if(stack[l]==0) { stack[l]=workstep[k]; cout<<"发生中断，但内存中有空闲区，"< interrupt++; goto step1; } } /*上述情况都不成立则调出栈顶，将调入页面插入栈顶*/ cout<<"发生中断，将"< interrupt++; /*新掉入的页面放栈顶*/ step1: for(int m=0;m { stack[m]=stack[m+1]; } stack[storesize-1]=workstep[k]; } cout<<"作业"< } 二、程序调试： 调试一： 请输入存储区块数：3 请输入作业走向（输入0结束）： 页面号1：4 页面号2：3 页面号3：2 页面号4：1 页面号5：4 页面号6：3 页面号7：5 页面号8：4 页面号9：3 页面号10：2 页面号11：1 页面号12：5 页面号13：0 输入结束！ 置换情况如下： 发生中断，但内存中有空闲区，4号页面直接调入！发生中断，但内存中有空闲区，3号页面直接调入！发生中断，但内存中有空闲区，2号页面直接调入！发生中断，将4号页面调出，1号装入！ 发生中断，将3号页面调出，4号装入！ 发生中断，将2号页面调出，3号装入！ 发生中断，将1号页面调出，5号装入！ 内存中有4号页面，无须中断！ 内存中有3号页面，无须中断！ 发生中断，将5号页面调出，2号装入！ 发生中断，将4号页面调出，1号装入！ 发生中断，将3号页面调出，5号装入！ 作业12个，中断10次，缺页率：83.3333% Press any key to continue 调试二： 请输入存储区块数：4 请输入作业走向（输入0结束）： 页面号1：4 页面号2：3 页面号3：2 页面号4：1 页面号5：4 页面号6：3 页面号7：5 页面号8：4 页面号9：3 页面号10：2 页面号11：1 页面号12：5 页面号13：0 输入结束！ 置换情况如下： 发生中断，但内存中有空闲区，4号页面直接调入！发生中断，但内存中有空闲区，3号页面直接调入！发生中断，但内存中有空闲区，2号页面直接调入！发生中断，但内存中有空闲区，1号页面直接调入！内存中有4号页面，无须中断！ 内存中有3号页面，无须中断！ 发生中断，将2号页面调出，5号装入！ 内存中有4号页面，无须中断！ 内存中有3号页面，无须中断！ 发生中断，将3号页面调出，2号装入！ 发生中断，将5号页面调出，1号装入！ 发生中断，将4号页面调出，5号装入！ 作业12个，中断8次，缺页率：66.6667% Press any key to continue 操作系统实验报告实验名称：文件管理 专业班级：网络工程1301 学号： 姓名： 2015 年6 月16 日 实验一文件管理 一、实验目的 文件管理是操作系统的一个非常重要的组成部分。学生应独立用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作命令的实质容和执行过程有比较深入的了解，掌握它们的实施方法，加深理解课堂上讲授过的知识。 二、预备知识 1.VS2010的使用 2.C#的学习 3.文件主目录与子目录的理解 三、实验容与步骤 用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。要求设计一个10 个用户的文件系统，每次用户可保存10 个文件，一次运行用户可以打开5 个文件。系统能够检查打入命令的正确性，出错时能显示出错原因。对文件必须设置保护措施，例如只能执行，允许读等。在每次打开文件时，根据本次打开的要求，在此设置保护级别，即有二级保护。文件的操作至少有Create、delete、open、close、read、write 等命令。 所编写的程序应采用二级文件目录，即设置主文件目录和用户文件目录。前者应包含文件主及它们的目录区指针；后者应给出每个文件占有的文件目录，即文件名，保护码，文件长度以及它们存放的位置等。另外为打开文件设置运行文件目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。 程序流程图： 逻辑设计： 使用线性数组表表示MFD，泛型数组表示UFD，每个元素包括用户ID、保存的文件数、再使用线性表表示文件信息，每个元素包括文件名，文件属性（保护码），文件的状态等信息。 物理设计： //主目录 private FileUser[] mfd; //当前用户 private FileUser currentuser; /// 操作系统上机题目 一、题目 实验1：LINUX/UNIX Shell部分 （一）系统基本命令 1．登陆系统，输入whoami 和pwd ，确定自己的登录名和当前目录； 登录名yuanye ，当前目录/home/yuanye 2．显示自己的注册目录?命令在哪里? a．键入echo $HOME，确认自己的主目录；主目录为/home/yuanye b．键入echo $PA TH，记下自己看到的目录表；/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games c．键入which abcd，看看得到的错误信息； 再键入which ls 和which vi，对比刚刚得到的结果的目录是否在a．、b． 两题看到的目录表中； /bin/ls /usr/bin/vi 3．ls 和cd 的使用: a．键入ls，ls -l ，ls -a ，ls -al 四条命令，观察输出，说明四种不同使用方式的区别。 1. examples.desktop 公共的模板视频图片文档音乐桌面; 总计32 2.-rw-r--r-- 1 yuanye yuanye 357 2011-03-22 22:15 examples.desktop drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 公共的 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 模板 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 视频 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 图片 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 文档 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 音乐 drwxr-xr-x 2 yuanye yuanye 4096 2011-03-22 23:25 桌面 3. . .fontconfig .local .Xauthority .. .gconf .mozilla .xsession-errors .bash_logout .gconfd .nautilus 公共的 .bashrc .gksu.lock .profile 模板 .cache .gnome2 .pulse 视频 .chewing .gnome2_private .pulse-cookie 图片 .config .gnupg .recently-used.xbel 文档 .dbus .gstreamer-0.10 .scim 音乐 .dmrc .gtk-bookmarks .sudo_as_admin_successful 桌面 .esd_auth .gvfs .update-manager-core 简单文件系统的设计及实现 一、实验目的： 1、用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解 2、要求设计一个 n个用户的文件系统，每次用户可保存m个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。 二、实验内容： 1、设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。 2、程序采用二级文件目录（即设置主目录[MFD]）和用户文件目录（UED）。另外，为打开文件设置了运行文件目录（AFD）。 3、为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作 4、算法与框图 ?因系统小，文件目录的检索使用了简单的线性搜索。 ?文件保护简单使用了三位保护码：允许读写执行、对应位为 1，对应位为0，则表示不允许读写、执行。 ?程序中使用的主要设计结构如下：主文件目录和用户文件目录（ MFD、UFD）； 打开文件目录（ AFD）（即运行文件目录） 文件系统算法的流程图如下 三、工具/准备工作： 在开始本实验之前，请回顾教科书的相关内容。并做以下准备： 1) 一台运行Windows 2000 Professional或Windows 2000 Server的操作系统的计算机。 2) 计算机中需安装Visual C++ 6.0专业版或企业版 四、实验要求： （１）按照学校关于实验报告格式的要求，编写实验报告（含流程图）； （２）实验时按两人一组进行分组，将本组认为效果较好的程序提交检查。 广州大学学生实验报告 1、实验目的 1.1、掌握进程的概念，明确进程的含义 1.2、认识并了解并发执行的实质 2.1、掌握进程另外的创建方法 2.2、熟悉进程的睡眠、同步、撤消等进程控制方法 3.1、进一步认识并发执行的实质 3.2、分析进程竞争资源的现象，学习解决进程互斥的方法 4.1、了解守护进程 5.1、了解什么是信号 5.2、INUX系统中进程之间软中断通信的基本原理 6.1、了解什么是管道 6.2、熟悉UNIX/LINUX支持的管道通信方式 7.1、了解什么是消息 7.2、熟悉消息传送的机理 8.1、了解和熟悉共享存储机制 二、实验内容 1.1、编写一段程序，使用系统调用fork( )创建两个子进程。当此程序运行时，在系统 中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示'a'，子进程分别显示字符'b'和字符'c'。试观察记录屏幕上的显示结果，并分析原因。 1.2、修改上述程序，每一个进程循环显示一句话。子进程显示'daughter …'及 'son ……'，父进程显示'parent ……'，观察结果，分析原因。 2.1、用fork( )创建一个进程，再调用exec( )用新的程序替换该子进程的内容 2.2、利用wait( )来控制进程执行顺序 3.1、修改实验（一）中的程序2，用lockf( )来给每一个进程加锁，以实现进程之间的互斥 3.2、观察并分析出现的现象 4.1、写一个使用守护进程(daemon)的程序，来实现： 创建一个日志文件/var/log/Mydaemon.log ； 每分钟都向其中写入一个时间戳(使用time_t的格式) ； 5.1、用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按^c键）；捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child process1 is killed by parent! Child process2 is killed by parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent process is killed! 5.2、用软中断通信实现进程同步的机理 实验5 文件系统：Linux文件管理 1．实验目的 （1）掌握Linux提供的文件系统调用的使用方法； （2）熟悉文件和目录操作的系统调用用户接口； （3）了解操作系统文件系统的工作原理和工作方式。 2．实验内容 （1）利用Linux有关系统调用函数编写一个文件工具filetools，要求具有下列功能：*********** 0. 退出 1. 创建新文件 2. 写文件 3. 读文件 4. 复制文件 5. 修改文件权限 6. 查看文件权限 7. 创建子目录 8. 删除子目录 9. 改变当前目录到指定目录 10. 链接操作 *********** 代码： #include menu(); scanf("%d",&choose); while(choose!=0) { switch(choose) { case 1:openfile();break; case 2:writefile();break; case 3:readfile();break; case 4:copyfile();break; case 5:chmd();break; case 6:ckqx();break; case 7:cjml();break; case 8:scml();break; case 9:ggml();break; case 10:ylj();break; } menu(); scanf("%d",&choose); } return 0; } void menu(void) { printf("文件系统\n"); printf("1.创建新文件\n"); printf("2.写文件\n"); printf("3.读文件\n"); printf("4.复制文件\n"); printf("5.修改文件权限\n"); printf("6.查看文件权限\n"); printf("7.创建子目录\n"); printf("8.删除子目录\n"); printf("9.改变目前目录到指定目录\n"); printf("10.链接操作\n"); printf("0.退出\n"); printf("请输入您的选择...\n"); } void openfile(void) { int fd; if((fd=open("/tmp/hello.c",O_CREAT|O_TRUNC|O_RDWR,0666))<0) perror("open"); 实验（一） Windows 7基本操作 一、实验目的 1．掌握文件和文件夹基本操作。 2．掌握“资源管理器”和“计算机”基本操作。 二、实验要求 1.请将操作结果用Alt+Print Screen组合键截图粘贴在题目之后。 2．实验完成后，请将实验报告保存并提交。 三、实验内容 1．文件或文件夹的管理（提示：此题自行操作一遍即可，无需抓图）★期末机试必考题★ (1) 在D：盘根目录上创建一个名为“上机实验”的文件夹，在“上机实验”文件夹中创建1个名为“操作系统上机实验”的空白文件夹和2个分别名为“2.xlsx”和“3.pptx”的空白文件，在“操作系统上机实验”文件夹中创建一个名为“1.docx”的空白文件。 (2) 将“1.docx”改名为“介绍信.docx”；将“上机实验”改名为“作业”。 (3) 在“作业”文件夹中分别尝试选择一个文件、同时选择两个文件、一次同时选择所有文件和文件夹。 (4) 将“介绍信.docx”复制到C：盘根目录。 (5) 将D：盘根目录中的“作业”文件夹移动到C：盘根目录。 (6) 将“作业”文件夹中的“2.xlsx”文件删除放入“回收站”。 (7) 还原被删除的“2.xlsx”文件到原位置。 2．搜索文件或文件夹，要求如下： 查找C盘上所有以大写字母“A”开头，文件大小在10KB以上的文本文件。（提示：搜索时，可以使用“?”和“*”。“？”表示任意一个字符，“*”表示任意多个字符。） 3. 在桌面上为C：盘根目录下的“作业”文件夹创建一个桌面快捷方式。★期末机试必考题★ 3．“计算机”或“资源管理器”的使用 (1) 在“资源管理器”窗口，设置以详细信息方式显示C:\WINDOWS中所有文件和文件夹，使所有图标按类型排列显示，并不显示文件扩展名。（提示：三步操作全部做完后，将窗口中显示的最终设置结果抓一张图片即可） (2) 将C：盘根目录中“介绍信.docx”的文件属性设置为“只读”和“隐藏”，并设置在窗口中显示“隐藏属性”的文件或文件夹。（提示：请将“文件夹”对话框中选项设置效果与C：盘根目录中该文件图标呈现的半透明显示效果截取在一整张桌面图片中即可） 4．回收站的设置 设置删除文件后，不将其移入回收站中，而是直接彻底删除功能。 大连理工大学实验报告 学院（系）：专业：班级： 姓名：学号：组：___ 实验时间：实验室：实验台： 指导教师签字：成绩： 实验名称：进程控制 一、实验目的和要求 （1）进一步加强对进程概念的理解，明确进程和程序的区别 （2）进一步认识并发执行的实质 二、实验环境 在windows平台上，cygwin模拟UNIX运行环境 三、实验内容 （1） getpid()---获取进程的pid 每个进程都执行自己独立的程序，打印自己的pid； （2） getpid()---获取进程的pid 每个进程都执行自己独立的程序，打印自己的pid； 父进程打印两个子进程的pid; （3）写一个命令处理程序，能处理max(m,n), min(m,n)，average(m,n,l)这几个命令（使用exec函数族）。 Max函数 Min函数 Average函数 Exec函数族调用 四、程序代码 五、运行结果 六、实验结果与分析 七、体会 通过这次上机，我了解了fork函数的运行方法，同时更深刻的了解了进程的并行执行的本质，印证了在课堂上学习的理论知识。同时通过编写实验内容（3）的命令处理程序，学会了exec函数族工作原理和使用方法。通过这次上机实验让我加深了对课堂上学习的理论知识的理解，收获很多。 大连理工大学实验报告 学院（系）：专业：班级： 姓名：学号：组：___ 实验时间：实验室：实验台： 指导教师签字：成绩： 实验名称：进程通讯 一、实验目的和要求 了解和熟悉UNIX支持的共享存储区机制 二、实验环境 在windows平台上，cygwin模拟UNIX运行环境 三．实验内容 编写一段程序, 使其用共享存储区来实现两个进程之间的进程通讯。进程A创建一个长度为512字节的共享内存，并显示写入该共享内存的数据；进程B将共享内存附加到自己的地址空间，并向共享内存中写入数据。 四、程序代码 五、运行结果 六、实验结果与分析 七、体会 实验四文件系统实验 一 . 目的要求 1、用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 2、要求设计一个 n个用户的文件系统，每次用户可保存m个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。 二 . 例题： 1、设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。 2、程序采用二级文件目录（即设置主目录[MFD]）和用户文件目录（UED）。另外，为打开文件设置了运行文件目录（AFD）。 3、为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。 4、算法与框图： ①因系统小，文件目录的检索使用了简单的线性搜索。 ②文件保护简单使用了三位保护码：允许读写执行、对应位为 1，对应位为0，则表示不允许读写、执行。 ③程序中使用的主要设计结构如下： 主文件目录和用户文件目录（ MFD、UFD） 打开文件目录（ AFD）（即运行文件目录） 文件系统算法的流程图如下： 三 . 实验题： 1、增加 2～3个文件操作命令，并加以实现。（如移动读写指针，改变文件属性，更换文件名，改变文件保护级别）。 #include 评分： SHANGHAI UNIVERSITY 操作系统实验报告 学院计算机工程与科学 专业计算机科学与技术 学号 学生姓名 《计算机操作系统》实验一报告 实验一题目：操作系统的进程调度 姓名：张佳慧学号 :12122544 实验日期： 2015.1 实验环境： Microsoft Visual Studio 实验目的： 进程是操作系统最重要的概念之一，进程调度又是操作系统核心的主要内容。本实习要求学生独立地用高级语言编写和调试一个简单的进程调度程序。调度算法可任意选择或自行设计。例如，简单轮转法和优先数法等。本实习可加深对于进程调度和各种调度算法的理解。实验内容： 1、设计一个有n个进程工行的进程调度程序。每个进程由一个进程控制块（PCB）表示。进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。 2、调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。 3、系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程。 操作过程： 1、本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一，并假设起始状态都是就绪状态W。为了便于处理，程序进程的运行时间以时间片为单位计算。进程控制块结构如下： 进程控制块结构如下： PCB 进程标识数 链指针 优先数/轮转时间片数 占用 CPU 时间片数 进程所需时间片数 进程状态 进程控制块链结构如下： 其中：RUN—当前运行进程指针； HEAD—进程就绪链链首指针； TAID—进程就绪链链尾指针。2、算法与框图 (1) 优先数法。进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。每过一个时间片，运行进程所需运行的时间片数减 1，说明它已运行了一个时间片，优先数也减 3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。 (2) 简单轮转法。进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。每过一个时间片，运行进程占用处理机的时间片数加 1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。 (3) 程序框图 操作系统上机实验报告 实验名称： 生产者与消费者问题模拟 实验目的： 通过模拟生产者消费者问题理解进程或线程之间的同步与互斥。 实验内容： 1、设计一个环形缓冲区，大小为10，生产者依次向其中写入1到20，每个缓冲区中存放一个数字，消费者从中依次读取数字。 2、相应的信号量； 3、生产者和消费者可按如下两种方式之一设计； (1)设计成两个进程； (2)设计成一个进程内的两个线程。 4、根据实验结果理解信号量的工作原理，进程或线程的同步\互斥关系。 实验步骤及分析： 一．管道 （一）管道定义 所谓管道，是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件，又称为pipe文件。由写进程从管道的写入端（句柄1）将数据写入管道，而读进程则从管道的读出端（句柄0）读出数据。（二）所涉及的系统调用 1、pipe( ) 建立一无名管道。 系统调用格式 pipe(filedes) 参数定义 int pipe(filedes); int filedes[2]; 其中，filedes[1]是写入端，filedes[0]是读出端。 该函数使用头文件如下： #include int read(fd,buf,nbyte); int fd; char *buf; unsigned nbyte; 3、write( ) 系统调用格式 read(fd,buf,nbyte) 功能：把nbyte 个字节的数据，从buf所指向的缓冲区写到由fd所指向的文件中。如文件加锁，暂停写入，直至开锁。 参数定义同read( )。 （三）参考程序 #include 实验报告 实验题目：文件系统 姓名： 学号： 课程名称：操作系统 所在学院：信息科学与工程学院 专业班级：计算机 任课教师： 实验项目名称文件系统 一、实验目的与要求： 1、通过一个简单多用户文件系统的设计,加深理解文件系统的内部功能及其内部实现。 2、熟悉文件管理系统的设计方法，加深对所学各种文件操作的了解及其操作方法的特点。 3、通过模拟文件系统的实现，深入理解操作系统中文件系统的理论知识, 加深对教材中的重要算法的理解。 4、通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。 二、实验设备及软件： 一台PC（Linux系统） 三、实验方法（原理、流程图） 试验方法 （1）首先应当确定文件系统的数据结构：主目录、子目录以及活动文件等。主目录和子 目录都以文件的形式存放于磁盘，这样便于查找和修改。 （2）用户创建文件，可以编号存储于磁盘上。如file0，file1，file2…并以编号作为物理地 址，在目录中登记。 文件系统功能流程图 图1.文件系统总体命令分析 图 2.登录流程图图 3. ialloc流程图 图4.balloc流程图图5.密码修改流程图 图6.初始化磁盘 图 7.显示所有子目录 dir/ls 操作流程图 图8.创建文件 creatfile 、创建目录 mkdir 流程图 图9.改变当前路径 cd 操作流程图 实验原理 1.文件操作 ◆mkdir 创建目录文件模块，输入 mkdir 命令，回车，输入文件名，回车，即会在当前目录文件下创建一个名为刚刚输入的文件名的目录文件。在该创建过程中首先要判断该目录中有没有同名的文件，如果有的话就创建失败，还要判断在该目录下有没有创建文件的权限，有权限才可以创建。具体流程图查看第二节，系统流程图设计部分。 ◆del 删除文件模块，输入 del命令，回车，输入文件名，回车，即会在当前目录文件下删除一个名为刚刚输入的文件名的数据文件。在该删除过程中要判断该目录中是否存在该文件，如果不存在就没有必要执行该操作了，还要判断在该目录下有没有删除文件的权限，有权限才可以删除。具体流程图查看第二节，系统流程图设计部分。 ◆ls 显示当前目录下所有目录的模块，输入 ls 命令，回车 ,即会在屏幕上显示当前目录下的所有目录。在该过程中要判断该目录中是否为空，如果为空就没有必要执行该操作了。执行操作时，要调用 readdir （INode inode ）函数 ,先读入文件内容到 content 里面，然后直接输出。如果子目录里面还有子目录，则通过递归，一并输出来。具体流程图查看第二节，系统流程图设计部分。 ◆chmod 改变文件权限模块，输入 chmod 命令，回车，输入文件名，回车，即会根据不同类别的用户在屏幕上提示要改变哪一类用户的权限。如果是文件拥有者执行该操作，他可以选择修改自己、其他用户的权限；如果是文件所属组成员执行该操作，他可以选择修改自己、其他用户的权限；如果是其他用户执行该操作，他只能选择修改自己的权限；在该过程中要判断该目录中是否存在该文件，如果不存在就没有必要执行该操作了。执行操作时，要判断对该文件有没有执行写操作的权利，没有就不能进行。具体流程图查看第二节，系统流程图设计部分。 ◆cd 改变当前所在目录的模块。输入 cd,回车，相应的字符串，回车，则会根据输入字符串的不同跳转到不同的目录下。如果字符串是‘ .’ ，则到当前目录；如果字符串是‘ ..’ ，则到父目录；如果字符串是‘/’ ，则到根目录；如果字符串是当前目录下的子目录，则到该子目录；如果字符串是一个决定路径，则到该绝对路径。当然在执行的时候要判断有没有该子目录或者该绝对路径，如果没有的话，就不能执行。具体流程图查看第二节，系统流程图设计部分。 2. 用户操作 ◆login 用户注销模块，输入 login ，回车，当前用户就退出了，需要重新登录。 ◆pw 用户修改口令模块，输入 pw ，回车，则会提示输入原始密码，输入正确了才可以提示输入新密码，并且要求新密码输入两次，两次一样了才能通过修改密码成功。具体流程图查看第二节，系统流程图设计部分。 ◆logout 用户退出系统模块，输入 logout ，回车，系统自动退出。 实验三操作系统进程管理 一、实验目的 1) 掌握系统进程的概念，加深对Linux / UNIX进程管理的理解。 2) 学会使用ps命令和选项。 3) 列出当前shell中的进程。 4) 列出运行在系统中的所有进程。 5) 根据命令名搜索特定的进程。 6) 使用kill命令终止进程。 7) 根据用户名查找和终止进程。 二、实验内容和相应的答案截图，三、实验结果分析 步骤1：创建一个普通用户（参见实验二），以普通用户身份登录进入GNOME。 步骤2：打开一个“终端”窗口（参见实验二）。 步骤3：回顾系统进程概念，完成以下填空： 1) Linux系统中，几乎每一个启动的进程，都会由内核分配一个唯一的__PID__进程标识符，用于跟踪从进程启动到进程结束。 2) 当启动新进程的时候，内核也给它们分配系统资源，如__内存_和__CPU_。 3) 永远不向父进程返回输出的进程叫做__僵进程__。 4) 由父进程派生出来的进程叫做____子___进程。 5) ___父_进程是一个派生另一个进程的进程。 6) 运行用于提供服务的Linux系统进程是_______________。 7) 如果父进程在子进程之前结束，它创建了一个______________进程。 步骤4：回顾ps命令和信息。基本的ps命令显示当前shell中的进程信息，用户只能够查看当前终端窗口中初始化的进程。输入ps命令，将结果填入表3-3中。 表3-3 实验记录 下面，在当前终端窗口中，练习使用给出的每个选项的ps命令。 输入ps -f 命令，显示运行在系统中的某个进程的完全信息，填入表3-4中。 表3-4 实验记录 步骤5：列出系统中运行的所有进程。 输入ps -ef 命令，显示运行在系统中的各个进程的完全信息。执行该命令，并与ps –f 命令的输出结果对照，一致吗？有何不同？ 答：不一致，后者显示了所有进程的完全可用信息，多了很多。 分析当前终端窗口中的输出结果，记录下来用于写实验报告。 a. 显示了多少个进程？答：59 b. 进程ID的PID是什么？ c. 启动进程的命令(CMD) 是什么？答：sched d. 请观察，什么命令的PID号是1？答：init[5] e. 执行ps –ef >aaa命令，将ps命令的输出送到文本文件aaa。再次运行cat aaa | wc命令，计算进程的数目。其中，cat是显示文本文件命令。“|”是管道命令，就是将前一个命令的输出作为后一个命令的输入。wc 命令用来计算文本的行数，第一个数字显示的是行的数目，可以用来计算进程的数目。计算出进程数目并做记录。 执行man ps命令，可以打开Linux用户命令手册。了解ps命令的用法。输入wq命令可退出用户手册的阅读。man命令可以执行吗？结果如何？ 答：Man ps时出现 #include char type; // 文件类型 char user_name[10]; // 文件所有者 short iparent; // 父目录的i节点号 short length; // 文件长度 short address[2]; // 存放文件的地址 } Inode; //打开文件表 typedef struct { short inum; // i节点号 char file_name[10]; // 文件名 short mode; // 读写模式(1:read, 2:write, // 3:read and write) } File_table; // 申明函数 void login(void); void init(void); int analyse(char *); void save_inode(int); int get_blknum(void); void read_blk(int); void write_blk(int); 许昌学院 《操作系统》实验报告书学号： 姓名：闫金科 班级：14物联网工程 成绩: 2016年02月 实验一Linux的安装与配置 一、实验目的 1.熟悉Linux系统的基本概念，比如Linux发行版、宏内核、 微内核等。 2.掌握Linux系统的安装和配置过程，初步掌握Linux系统的 启动和退出方法。 3.熟悉Linux系统的文件系统结构，了解Linux常用文件夹的 作用。 二、实验内容 1.从网络上下载VMware软件和两个不同Linux发行版镜像文 件。 2.安装VMware虚拟机软件。 3.在VMware中利用第一个镜像文件完成第一个Linux的安装， 期间完成网络信息、用户信息、文件系统和硬盘分区等配 置。 4.在VMware中利用第二个镜像文件完成第二个Linux的安装， 并通过LILO或者GRUB解决两个操作系统选择启动的问题。 5.启动Linux系统，打开文件浏览器查看Linux系统的文件结 构，并列举出Linux常用目录的作用。 三、实验过程及结果 1、启动VMware，点击新建Linux虚拟机，如图所示： 2、点击下一步，选择经典型，点击下一步在选择客户机页面选择Linux，版本选择RedHatEnterpriseLinux5，如图所示： 3、点击下一步创建虚拟机名称以及所要安装的位置，如图所示： 4、点击下一步，磁盘容量填一个合适大小，此处选择默认值大小10GB，如图所示： 5、点击完成，点击编辑虚拟机设置，选择硬件选项中的CD-ROM（IDE...）选项，在右侧连接中选择“使用ISO镜像（I）”选项，点击“浏览”，找到Linux的镜像文件，如图所示： 6点击确定按钮后，点击启动虚拟机按钮，来到Linux的安装界面，如图所示： 7、到此页面之后，等待自动检测安装，如图所示： 8、等到出现如图所示页面后点击“skip”按钮，跳过检测，直接进入安装设置界面，如图所示： 9、安装设计界面如图所示： 10、点击Next按钮进入设置语言界面，设置语言为“简体中文”，如图所示： 11、点击Nest按钮进入系统键盘设置按钮，设置系统键盘为“美国英语式”，如图所示： 12、点击下一步按钮，弹出“安装号码”对话框，选择跳 实验二进程调度 1．目的和要求 通过这次实验，理解进程调度的过程，进一步掌握进程状态的转变、进程调度的策略，进一步体会多道程序并发执行的特点，并分析具体的调度算法的特点，掌握对系统性能的评价方法。 2．实验内容 阅读教材《计算机操作系统》第二章和第三章，掌握进程管理及调度相关概念和原理。 编写程序模拟实现进程的轮转法调度过程，模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。假设初始状态为：有 n 个进程处于就绪状态，有m个进程处于阻塞状态。采用轮转法进程调度算法进行调度（调度过程中，假设处于执行状态的进程不会阻塞），且每过 t 个时间片系统释放资源，唤醒处于阻塞队列队首的进程。 程序要求如下： 1）输出系统中进程的调度次序； 2）计算CPU利用率。 3．实验环境 Windows操作系统、VC++6.0 C语言 4 设计思想： (1)程序中进程可用PCB表示，其类型描述如下： struct PCB_type { int pid ;// 进程名 int state ;// 进程状态 2——表示“执行”状态 1——表示“就绪”状态 0——表示“阻塞”状态 int cpu_time ; //运行需要的CPU寸间(需运行的时间片 个数) } 用PCB来模拟进程； (2)设置两个队 列，将处于“就绪”状态的进程PCB挂在队列readyxx ;将处于“阻塞”状态的进程 PCB挂在队列blockedxx。 队列类型描述如下： struct QueueNode{ struct PCB_type PCB; Struct QueueNode *next; } 并设全程量： struct QueueNode *ready_head=NULL,//ready 队列队首指针 *ready_tail=NULL , //ready 队列队尾指针 *blocked_head=NULL,//blocked 队列队首指 针 *blocked_tail=NULL; //blocked 队列队尾指 针 (3)设计子程序： start_state(); 读入假设的数据，设置系统初始状态，即初始化就绪队列和 阻塞队列 dispath(); 模拟调度，当就绪队列的队首进程运行一个时间片后，放到就绪队列末尾，每次都是队首进程进行调度，一个进程运行结束 就从就绪队列中删除，当到 t 个时间片后，唤醒阻塞队列队首进程。 哈尔滨工业大学计算机科学与技术学院 实验报告 课程名称：操作系统 课程类型：必修 实验项目名称：文件管理 实验题目：设计一个多用户的文件系统 班级：实验学院一班 学号：6040310110 姓名：张元竞 设计成绩报告成绩指导老师 一、实验目的 随着社会信息量的极大增长，要求计算机处理的信息与日俱增，涉及到社会生活的各个方面。因此，文件管理是操作系统的一个非常重要的组成部分。学生应独立用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深理解课堂上讲授过的知识。 二、实验要求及实验环境 用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。要求设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。系统能够检查打入命令的正确性，出错时能显示出错原因。对文件必须设置保护措施，例如只能执行，允许读等。在每次打开文件时，根据本次打开的要求，在此设置保护级别，即有二级保护。文件的操作至少有Create、delete、open、close、read、write等命令。 所编写的程序应采用二级文件目录，即设置主文件目录和用户文件目录。前者应包含文件主及它们的目录区指针；后者应给出每个文件占有的文件目录，即文件名，保护码，文件长度以及它们存放的位置等。另外为打开文件设置运行文件目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。 三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）操作系统文件管理实验报告
操作系统上机实验报告(西电)
操作系统简单文件系统设计及实现
操作系统实验实验1
操作系统实验5文件系统：Linux文件管理
《 Windows7 操作系统》实验报告
操作系统上机实验报告
实验四 文件系统实验报告
上海大学操作系统(二)实验报告(全)
操作系统实验报告生产者与消费者问题模拟
操作系统实验---文件系统
操作系统实验3答案
操作系统实验文件管理C 代码
操作系统实验报告
操作系统实验报告
计算机操作系统实验-文件管理
- 操作系统模拟unix文件系统实验报告要点
- 操作系统实验---文件系统
- 操作系统文件系统模拟设计实验报告
- 操作系统实验六文件系统设计试验
- 操作系统课程设计简单文件系统的实现
- 操作系统实验-文件系统
- 操作系统 实验六 文件系统设计试验
- 操作系统实验-文件系统设计
- 操作系统课程设计文件系统
- 《操作系统》实验报告四-磁盘文件操作
- 操作系统课程设计 文件系统管理
- 实验四 文件系统实验报告
- FAT文件系统操作系统课程设计实验报告
- 操作系统文件系统实验
- 操作系统实验五-文件系统
- 操作系统课程设计(文件系统管理)
- 操作系统实验报告
- 操作系统文件系统模拟课程设计实验报告
- 第七章 文件系统实验
- 操作系统模拟unix文件系统实验报告