操作系统实验八综合实验代码
北京邮电大学计算机学院 - 操作系统实验报告(含源代码)

1/58
10 年 12 月 19 日
内容目录
实验 1.3 Shell 编程...........................................................4 1、实验目的...............................................................4 2、实验内容...............................................................4 3、实验原理...............................................................4 4、实验步骤...............................................................4 5、实验结果:.............................................................4 6、人员任务分配...........................................................5
实验项目:
1. 实验 1.3 Shell 编程 2. 实验 2.3 内核模块 3. 实验 2.4 系统调用 4. 实验 3.3 Shell 编程实验(进程管理实验) 5. 实验 4.1 观察实验(存储管理实验) 6. 实验 5.1 观察实验(进程通信) 7. 实验 6.3 Io 系统编程实验 8. 实验 6.4 设备驱动程序 9. 实验 7.1 代码分析(文件系统管理实验)
实验 3.3 Shell 编程实验(进程管理实验)......................................18 1、实验目的..............................................................18 2、实验内容..............................................................18 3、实验原理..............................................................18 4、实验步骤..............................................................18 5、实验结果及分析........................................................19 6、人员任务分配..........................................................19 2、实验内容 2............................................................20 3、实验原理..............................................................20 4、实验步骤..............................................................20 5、实验结果及分析........................................................23 6、人员分配..............................................................24
操作系统实验参考代码

目录实验一WINDOWS进程初识 (2)实验二进程管理 (6)实验三进程同步的经典算法 (10)实验四存储管理 (14)试验五文件系统试验 (18)实验有关(参考)代码实验一WINDOWS进程初识1、实验目的(1)学会使用VC编写基本的Win32 Consol Application(控制台应用程序)。
(2)掌握WINDOWS API的使用方法。
(3)编写测试程序,理解用户态运行和核心态运行。
2、程序清单清单1-1 一个简单的Windows控制台应用程序// hello项目# include <iostream>void main(){std::cout << “Hello, Win32 Consol Application” << std :: endl ;}清单1-2 核心态运行和用户态运行时间比计算// proclist项目# include <windows.h># include <tlhelp32.h># include <iostream.h>// 当在用户模式机内核模式下都提供所耗时间时,在内核模式下进行所耗时间的64位计算的帮助方法DWORD GetKernelModePercentage(const FILETIME& ftKernel,const FILETIME& ftUser){// 将FILETIME结构转化为64位整数ULONGLONG qwKernel=(((ULONGLONG)ftKernel.dwHighDateTime)<<32)+ftKernel.dwLowDateTime;ULONGLONG qwUser=(((ULONGLONG)ftUser.dwHighDateTime)<<32)+ftUser.dwLowDateTime;// 将消耗时间相加,然后计算消耗在内核模式下的时间百分比ULONGLONG qwTotal=qwKernel+qwUser;DWORD dwPct=(DWORD)(((ULONGLONG)100*qwKernel)/qwTotal);return(dwPct);}// 以下是将当前运行过程名和消耗在内核模式下的时间百分数都显示出来的应用程序void main(int argc,char *argv[]){if(argc<2){cout<<"请给出你要查询的程序名"<<endl;exit(0);}// 对当前系统中运行的过程拍取“快照”HANDLE hSnapshot=::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,// 提取当前过程0);// 如果是当前过程,就将其忽略// 初始化过程入口PROCESSENTRY32 pe;::ZeroMemory(&pe,sizeof(pe));pe.dwSize=sizeof(pe);BOOL bMore=::Process32First(hSnapshot,&pe);BOOL found = FALSE;while(bMore){// 打开用于读取的过程if(!strcmp(pe.szExeFile,argv[1])){found = TRUE;HANDLE hProcess=::OpenProcess(PROCESS_QUERY_INFORMA TION,// 指明要得到信息FALSE,// 不必继承这一句柄pe.th32ProcessID);// 要打开的进程if (hProcess!=NULL){// 找出进程的时间FILETIME ftCreation,ftKernelMode,ftUserMode,ftExit;::GetProcessTimes(hProcess,// 所感兴趣的进程&ftCreation,// 进程的启动时间&ftExit,// 结束时间(如果有的话)&ftKernelMode,// 在内核模式下消耗的时间&ftUserMode);// 在用户模式下消耗的时间// 计算内核模式消耗的时间百分比DWORD dwPctKernel=::GetKernelModePercentage(ftKernelMode,// 在内核模式上消耗的时间ftUserMode);// 在用户模式下消耗的时间// 向用户显示进程的某些信息cout<< "process ID: " << pe.th32ProcessID<< ",EXE file:" << pe.szExeFile<< ",%d in Kernel mode: " << dwPctKernel << endl;// 消除句柄::CloseHandle(hProcess);}}// 转向下一个进程bMore=::Process32Next(hSnapshot,&pe);}if(found==FALSE){cout<<"当前系统没有这个可执行程序正在运行"<<endl;exit(0);}}清单1-3 核心态运行和用户态运行时间测试程序#include <stdio.h>main(){int i,j;while(1){for(i=0;i<1000;i++);for(j=1;j<1000;j++) printf(“enter kernel mode running.”);}}实验二进程管理1、实验目的1) 通过创建进程、观察正在运行的进程和终止进程的程序设计和调试操作,进一步熟悉操作系统的进程概念,理解Windows进程的“一生”。
操作系统实训过程代码

实训过程(步骤)或程序代码:#include <stdio.h>#include <stdlib.h>/*----------------------常量定义--------------------*/#define F 0#define T 1#define n 5 //进程数量#define m 4 //资源种类数量/*--------------------------------------------------*//*--------------------数据结构定义------------------*/int Available[m]={3,3,2}; //可用资源int Finish[n]; //用以判断系统是否有足够资源分给相应进程void Recycle(); //若进程运行完资源回收int backDos(); //判断所有进程是否运行完,完后返回操作系统/*--------------------------------------------------*//*-----------------------进程-----------------------*/struct PCB{ int flag; //状态标志,是否运行完int Max[m]; //资源最大需求量int Allocation[m]; //已分配资源int Need[m]; //还需要的资源int Request[m]; //请求资源量}P[n];/*-----------------------函数声明--------------------*/int tryAdminister(int num);//试分配void safeCheck(int num); //安全性检查void Print(); //状态输出/*主函数(只需改变n、m和下面的初始数组便可形成新的进程量,资源量和状态)*/ int main(){ int i, j, num;int total[n][m]={{7,5,3,1},{3,2,2,1},{9,0,2,2},{2,2,2,1},{4,3,3,3}};int have[n][m]={{0,1,0,0},{2,0,0,0},{3,0,2,2},{2,1,1,0},{0,0,2,1}};int want[n][m]={{7,4,3,0},{1,2,2,1},{6,0,0,0},{0,1,1,1},{4,3,1,2}};for (i=0;i<n;i++) //初始化进程资源分配状态for (j=0;j<m;j++){ P[i].flag = F;P[i].Max[j]=total[i][j];P[i].Allocation[j]=have[i][j];P[i].Need[j]=want[i][j];}Print(); //状态输出while (scanf("%d",&num)!=EOF){ printf("输入进程%d对这三类资源的需求向量(用空格隔开):\n",num);scanf("%d%d%d",&P[num].Request[0],&P[num].Request[1],&P[num].Request[2], &P[num].Request[3]);if (tryAdminister(num)==T)safeCheck(num);Recycle(); //资源回收if(backDos()==T) //所有进程完则返回操作系统return 0;Print();}return 0;}/*--------------------------------------------------------------------*//*----------------------------试分配函数-----------------------------*/int tryAdminister(int num) //试分配{ int j;for (j=0;j<m;j++)if (P[num].Request[j]>P[num].Need[j])printf("非法请求!\n\n");return F;}else if (P[num].Request[j]>Available[j]){ printf("%d号资源不够,无法分配,进程%d等待。
操作系统上机实验代码

操作系统上机实验代码修改后的md命令程序:int MdComd(int k) //md命令处理函数{// 命令形式:md <目录名>// 功能:在指定路径下创建指定目录,若没有指定路径,则在当前目录下创建指定目录。
// 对于重名目录给出错误信息。
目录与文件也不能重名。
// 学生可以考虑命令中加“属性”参数,用于创建指定属性的子目录。
命令形式如下:// md <目录名>[ <属性>]// 属性包括R、H、S以及它们的组合(不区分大小写,顺序也不限)。
例如:// md user rh// 其功能是在当前目录中创建具有“只读”和“隐藏”属性的子目录user。
short i,s,s0,kk;char attrib=(char)16,*DirName;FCB *p;char str[20]="|";kk=SIZE/sizeof(FCB);if (k<1){cout<<"\错误:命令中没有目录名。
\";return -1;}if (k>2){cout<<"\错误:命令参数太多。
\";return -1;}s=ProcessPath(comd[1],DirName,k,0,attrib);if (s<0)return s; //失败,返回if (!IsName(DirName)) //若名字不符合规则{cout<<"\命令中的新目录名错误。
\";return -1;}i=FindFCB(DirName,s,attrib,p);if (i>0){cout<<"\错误:目录重名!\";return -1;}if (k==2) //命令形式:md <目录名> <属性符>{i=GetAttrib(strcat(str,comd[2]),attrib);//由i=GetAttrib(comd[2],attrib);if (i<0)return i;}s0=FindBlankFCB(s,p);//找空白目录项if (s0<0) //磁盘满return s0;s0=M_NewDir(DirName,p,s,attrib); //在p所指位置创建一新子目录项if (s0<0) //创建失败{cout<<"\磁盘空间已满,创建目录失败。
操作系统实验算法代码 文档

// 三个算法.cpp : 定义控制台应用程序的入口点。
//#include "stdafx.h"#include<stdio.h>#include<stdlib.h>#include<iostream>#include"time.h"using namespace std;#define RR 2 //时间片大小#define FALSE 0#define TRUE 1#define W 10 //最大进程数W=10#define R 20 //最大资源总数R=20#define Random(x) (rand()%x)//rand是个伪随机数,拿当前时间做种子,获取的数是4位数,如何随机获取1到6,且1到6这6个数机会相等,//random(int n)是获取[0,n)的随机数int M ; //总进程数int N ; //资源种类数int ALL_RESOURCE[W];int A V AILABLE[R]; //可利用资源向量int MAX[W][R]; //最大需求矩阵int ALLOCATION[W][R]; //分配矩阵int NEED[W][R]; //需求矩阵int Request[R]; //进程请求向量void inputdata(); //数据输入void showdata(); //数据显示void changdata(int k);//进程请求资源数据改变void restoredata(int k); //数据恢复int chksec(int s); //系统安全性的检测int chkmax(int s); //检测最大需求void bank(); //检测分配的资源是否合理/*****************************使用先来先服务算法进行进程调度start*****************************/typedef struct Lnode{int name; //进程名int time; //到达时间int runtime; //运行时间int condition; //进程状态:1为就绪,0为完成struct Lnode *next;}Lnode,*PCB;void InitLnode(PCB &head1,PCB &head2,int n){PCB p,q,s,t;head1=(Lnode *)malloc(sizeof(Lnode));head1->next=NULL;head2=(Lnode *)malloc(sizeof(Lnode));head2->next=NULL;cout<<"====================按照FCFS算法实现进程管理============="<<endl;srand((int)time(0));//以当前时间对应的int值为随机序列起点p=(Lnode *)malloc(sizeof(Lnode));p->next=head1->next;head1->next=p;s=(Lnode *)malloc(sizeof(Lnode));s->next=head2->next;head2->next=s;p->name=1;p->time=Random(10);p->runtime=Random(10);p->condition=1;for(int i=0;i<n-1;i++){//用随机数赋值q=(Lnode *)malloc(sizeof(Lnode));q->name=i+2;q->time=Random(10);q->runtime=Random(10);q->condition=1;q->next=p->next;p->next=q;p=q;t=(Lnode *)malloc(sizeof(Lnode));t->next=s->next;s->next=t;s=t;}}void Display(PCB &head,int n){PCB p;p=head->next;cout<<"初始进程分配如下表:"<<endl;cout<<"进程名到达时间运行时间状态"<<endl;for(int i=0;i<n;i++){cout<<p->name<<" "<<p->time<<" "<<p->runtime<<""<<p->condition;p=p->next;cout<<endl;}cout<<endl;}void Findandcopy(PCB &head1,PCB &head2,int n){//p指向链表1的头结点,q指向链表2的第一个结点,front存最小结点前的节点,small 存最小结点int temp;//存放最小时间PCB p,q,front,small;p=head1;q=head2->next;temp=p->next->time;// Lnode* small;front=(Lnode *)malloc(sizeof(Lnode));front=p;small=p->next;int listCount = n; //另一个链表长度,因为会删除所以需要计数.for(int i=0;i<n;i++){p=head1;temp=p->next->time;for(int j=0;j<listCount;j++){//目的:找出链表1中最小的节点并存入链表2中,再把链表1中该结点删除if(p->next->time<=temp){temp=p->next->time;front=p;//保存最小的前一个节点small=p->next;//保存最小结点p=p->next;}else{p=p->next;}}front->next=small->next;q->condition=small->condition;q->name=small->name;q->runtime=small->runtime;q->time=small->time;q=q->next;free(small);//删除这个最小结点.listCount--;//长度减1.}}void Result(PCB &head,int n){PCB p;int temp;p=head->next;cout<<"经过变换后的管理顺序为:"<<endl;cout<<"进程名到达时间运行时间状态"<<endl;for(int i=0;i<n;i++){if(p->runtime==0){p->condition=0;}cout<<p->name<<" "<<p->time<<" "<<p->runtime<<""<<p->condition<<endl;temp=p->runtime;while(--temp>0){if(temp==1){p->condition=0;}cout<<p->name<<" "<<p->time<<" "<<temp<<""<<p->condition<<endl;}p=p->next;}}int FCFS(){int n;Lnode *p,*final;cout<<"请输入有几个进程:"<<endl;cin>>n;InitLnode(p,final,n);Display(p,n);Findandcopy(p,final,n);Result(final,n);return 1;}/*****************************时间片轮转算法*****************************/struct pro{char num[20];//进程名int arriveTime;int burst;//运行时间int rt; //记录进程被运行的次数int weight; //优先数struct pro *next;};int TOTALTIME; //记录所有进程的总时间//函数声明void insert(struct pro *head,struct pro *s); //插入节点按时间从小到达建立链表struct pro* searchByAT(struct pro *head,int AT); //查找第一个到达时间大于等于AT的节点,返回其前一个指针void del(struct pro* p);//删除p的下一个节点int getCount(struct pro *head,int time);//察看在time之前到达但未移动到运行队列的进程数量struct pro* searchEnd(struct pro *head); //查找并返回循坏队列的尾节点的前一个节点void move(struct pro *headF,struct pro *headT,int n); //将headF后的n个节点移动到循环队列headT中void run(struct pro *head);void del(struct pro* p);int getCount2(struct pro *head,int time);void insert(struct pro *head,struct pro *s) //插入节点按时间从小到达建立链表{struct pro *p=searchByAT(head,s->arriveTime);s->next=p->next;p->next=s;return;}struct pro* searchByAT(struct pro *head,int AT) //查找第一个到达时间大于等于AT的节点,返回其前一个指针{struct pro *p,*q;p=head;q=head->next;while(q!=NULL&&q->arriveTime<=A T){p=q;q=q->next;}return p;//指向最小时间点}int getCount(struct pro *head,int time) //察看在time之前到达但未移动到运行队列的进程数量{int count=0;struct pro *s,*t;s=head;t=s->next;while(t!=NULL&&t->arriveTime<=time){s=t;t=t->next;count++; //count记录当前时刻到达的进程数}return count;}struct pro* searchEnd(struct pro *head) //查找并返回循坏队列的尾节点的前一个节点{struct pro *p,*q;p=head;q=head->next;while(q->next!=head){p=q;q=q->next;}return p;}void del(struct pro* p) //删除p的下一个节点{struct pro *tmp;tmp=p->next;p->next=tmp->next;free(tmp);return;}void move(struct pro *headF,struct pro *headT,int n) //将headF后的n个节点移动到循环队列headT中{struct pro *r,*s,*t;s=headF;t=s->next;r=t; //r记录要移动的第一个节点while(n>1){t=t->next;}s->next=t->next; //以上完成从原队列中摘除相关节点,r,t分别为第一个和最后一个节点s=searchEnd(headT);t->next=s->next;s->next=r;}void run(struct pro *head){int time=0; //记录当前时间int newarrive;//新到达进程数struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));runhead->next=runhead; //创建新的循环链表,存放当前就绪队列中的进程struct pro *p,*q;p=runhead;q=p->next; //q记录当前应当运行的进程while(time<=TOTALTIME){newarrive=getCount(head,time);if(newarrive>0)move(head,runhead,newarrive); //将head后的newarrive个节点移动到runhead队列中if(runhead->next==runhead) //就绪队列中没有进程time++;elseif(q==runhead){p=q;q=q->next;}else{printf(" 进程名:%s\n",q->num);printf(" 到达时间:%d\n",q->arriveTime);if(q->rt==1)printf(" 等待时间:%d\n",time-q->arriveTime);elseprintf(" 第%d次运行开始时间:%d\n",q->rt,time);if(q->burst<=RR){time+=q->burst;printf(" 第%d次运行结束时间:%d\n",q->rt,time);printf(" 周转时间:%d\n",time-q->arriveTime);printf("*********************************************************\n");struct pro *tmp=q;q=q->next;p->next=q;free(tmp);}else //q->burst>RR{time+=RR;printf(" 第%d次运行结束时间:%d\n",q->rt,time);printf("*********************************************************\n");q->burst-=RR;q->rt++;p=q;q=q->next;}}}}/******************************短作业优先算法*****************************/int getCount2(struct pro *head,int time) //察看当前就绪队列中的进程数{int count=0;struct pro *p,*q;p=head;q=p->next;while(q!=NULL&&q->arriveTime<=time){count++;p=q;q=q->next;}return count;}struct pro* SJF(struct pro *head,int count) //在头节点后的count个节点中选择burst最小的,返回其前一个节点的指针{int min;struct pro *p,*q,*flag;p=head;q=p->next;min=q->burst;flag=p; //flag记录返回指针while(count>0){if(q->burst<min){min=q->burst;flag=p;}count--;p=q;q=q->next;}return flag;}void run2(struct pro *head) //按短作业优先算法调度进程,并输出其运行情况{int time=0,count;struct pro *s,*t;while(head->next!=NULL){count=getCount2(head,time);if(count==0) //如果当前就绪队列中没有进程,时间自增time++;elseif(count==1) //如果就绪队列中只有1个进程,则必定是第一个节点{t=head;s=t->next;printf(" 进程名:%s\n",s->num);printf(" 到达时间:%d\n",s->arriveTime);printf(" 运行开始时间:%d\n",time);printf(" 等待时间:%d\n",time-s->arriveTime);time+=s->burst;printf(" 运行结束时间:%d\n",time);printf(" 周转时间:%d\n",time-s->arriveTime);printf("******************************************************\n");del(t);}else //如果就绪队列中的进程数>=2,则在head后的count个节点中进行短作业优先调度{t=SJF(head,count);s=t->next;printf(" 进程名:%s\n",s->num);printf(" 到达时间:%d\n",s->arriveTime);printf(" 运行开始时间:%d\n",time);printf(" 等待时间:%d\n",time-s->arriveTime);time+=s->burst;printf(" 运行结束时间:%d\n",time);printf(" 周转时间:%d\n",time-s->arriveTime);printf("******************************************************\n");del(t);}}}/*****************************优先级计算法*****************************/struct pro* youxian(struct pro *head,int count) //在头节点后的count个节点中选择weight最小的,返回其前一个节点的指针{int min;struct pro *p,*q,*flag;p=head;q=p->next;min=q->weight;flag=p; //flag记录返回指针while(count>0){if(q->weight<min){min=q->weight;flag=p;}count--;p=q;q=q->next;}return flag;}void run3(struct pro *head) //按优先级算法调度进程,并输出其运行情况{int time=0,count;struct pro *s,*t;while(head->next!=NULL){count=getCount2(head,time);if(count==0) //如果当前就绪队列中没有进程,时间自增time++;else if(count==1) //如果就绪队列中只有1个进程,则必定是第一个节点{t=head;s=t->next;printf(" 进程名:%s\n",s->num);printf(" 到达时间:%d\n",s->arriveTime);printf(" 运行开始时间:%d\n",time);printf(" 等待时间:%d\n",time-s->arriveTime);time+=s->burst;printf(" 运行结束时间:%d\n",time);printf(" 周转时间:%d\n",time-s->arriveTime);printf("******************************************************\n");del(t);}else //如果就绪队列中的进程数>=2,则在head后的count个节点中进行短作业优先调度{t=youxian(head,count);s=t->next;printf(" 进程名:%s\n",s->num);printf(" 到达时间:%d\n",s->arriveTime);printf(" 运行开始时间:%d\n",time);printf(" 等待时间:%d\n",time-s->arriveTime);time+=s->burst;printf(" 运行结束时间:%d\n",time);printf(" 周转时间:%d\n",time-s->arriveTime);printf("******************************************************\n");del(t);}}}///////////////////////////////////////////银行家start/////////////////////////////////////////////////////void yinhangjia(){ int i,j;inputdata(); //数据输入for(i=0;i<M;i++){ j=chksec(i);//系统安全性的检测if (j==0) break;}if (i>=M)cout<<"错误提示:经安全性检查发现,系统的初始状态不安全!!!\n"<<endl;else{ cout<<"提示:经安全性检查发现,系统的初始状态安全!"<<endl;bank();//检测分配的资源是否合理}}void inputdata(){ int i=0,j=0,p;cout<<"请输入总进程数:"<<endl;do{cin>>M;if (M>W) cout<<endl<<"总进程数超过了程序允许的最大进程数,请重新输入:"<<endl;}while (M>W);cout<<endl;cout<<"请输入资源的种类数:"<<endl;do {cin>>N;if (N>R)cout<<endl<<"资源的种类数超过了程序允许的最大资源种类数,请重新输入:"<<endl; }while (N>R);cout<<endl;cout<<"请依次输入各类资源的总数量,即设置向量all_resource:"<<endl;for(i=0;i<N;i++) cin>>ALL_RESOURCE[i];cout<<endl;cout<<"请依次输入各进程所需要的最大资源数量,即设置矩阵max:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do { cin>>MAX[i][j];if (MAX[i][j]>ALL_RESOURCE[j])cout<<endl<<"该最大资源数量超过了声明的该资源总数,请重新输入:"<<endl; }while (MAX[i][j]>ALL_RESOURCE[j]);}}cout<<endl;cout<<"请依次输入各进程已经占据的各类资源数量,即设置矩阵allocation:"<<endl;for (i=0;i<M;i++){for (j=0;j<N;j++){do{ cin>>ALLOCA TION[i][j];if (ALLOCA TION[i][j]>MAX[i][j])cout<<endl<<"已占有的资源数量超过了声明的最大资源数量,请重新输入:"<<endl;}while (ALLOCA TION[i][j]>MAX[i][j]);}}cout<<endl;for (i=0;i<M;i++)for(j=0;j<N;j++)NEED[i][j]=MAX[i][j]-ALLOCATION[i][j];//cout<<"请输入系统中还可利用得各资源数量,即设置向量available:"<<endl;// for (j=0;j<N;j++)// {// cin>>A V AILABLE[j];// }for (j=0;j<N;j++){ p=ALL_RESOURCE[j];for (i=0;i<M;i++){ p=p-ALLOCATION[i][j];A V AILABLE[j]=p;if(A V AILABLE[j]<0)A V AILABLE[j]=0;}}}void showdata(){ int i,j;cout<<"各种资源的总数量,即向量all_resource为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<ALL_RESOURCE[j];cout<<endl<<endl;cout<<"当前系统中各类资源的可用数量,即向量available为:"<<endl;cout<<" ";for (j=0;j<N;j++)cout<<" 资源"<<j<<": "<<A V AILABLE[j];cout<<endl<<endl;cout<<"各进程还需要的资源数量,即矩阵need为:"<<endl<<endl;for (i=0;i<M;i++){ cout<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<NEED[i][j]<<" ";cout<<endl;}cout<<endl;cout<<"各进程已经得到的资源量,即矩阵allocation为: "<<endl<<endl;for (i=0;i<M;i++){ c out<<"进程P"<<i<<": ";for (j=0;j<N;j++)cout<<ALLOCATION[i][j]<<" ";cout<<endl;} cout<<endl;}//进程请求资源数据改变void changdata(int k){ int j;for (j=0;j<N;j++){A V AILABLE[j]=A V AILABLE[j]-Request[j];ALLOCATION[k][j]=ALLOCA TION[k][j]+Request[j];NEED[k][j]=NEED[k][j]-Request[j];}}//数据恢复void restoredata(int k){int j;for (j=0;j<N;j++){ A V AILABLE[j]=A V AILABLE[j]+Request[j];ALLOCATION[k][j]=ALLOCA TION[k][j]-Request[j];NEED[k][j]=NEED[k][j]+Request[j];}}int chksec(int s) //安全性检查{int WORK,FINISH[W];int i,j,k=0;for(i=0;i<M;i++)FINISH[i]=FALSE;for(j=0;j<N;j++){ WORK=A V AILABLE[j];i=s;do{ if(FINISH[i]==FALSE&&NEED[i][j]<=WORK){WORK=WORK+ALLOCATION[i][j];FINISH[i]=TRUE;i=0;}else{ i++;}}while(i<M);for(i=0;i<M;i++)if(FINISH[i]==FALSE){ return 1;}} return 0;}//检测最大需求int chkmax(int s){ int j,flag=0;for(j=0;j<N;j++){if (MAX[s][j]==ALLOCATION[s][j]){ flag=1;A V AILABLE[j]=A V AILABLE[j]+MAX[s][j];MAX[s][j]=0;}} return flag;}//检测分配的资源是否合理void bank(){int i=0,j=0;char flag='Y';while(flag=='Y'||flag=='y'){i=-1;while(i<0||i>=M){ cout<<"请输入需申请资源的进程号(从P0到P"<<M-1<<",否则重新输入!):";cout<<"p";cin>>i;if(i<0||i>=M)cout<<"输入的进程号不存在,重新输入!"<<endl;}cout<<"请输入进程P"<<i<<"申请的资源数:"<<endl;for (j=0;j<N;j++){ cout<<" 资源"<<j<<": ";cin>>Request[j];if(Request[j]>NEED[i][j]){ cout<<"进程P"<<i<<"申请的资源数大于进程P"<<i<<"还需要"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}else{ i f(Request[j]>A V AILABLE[j]){ cout<<"进程P"<<i<<"申请的资源数大于系统可用"<<j<<"类资源的资源量!";cout<<"申请不合理,出错!请重新选择!"<<endl<<endl;flag='N';break;}}}if(flag=='Y'||flag=='y'){changdata(i); //进程请求资源数据改变if(chksec(i)) //安全性检查{ cout<<endl;cout<<"该分配会导致系统不安全!!! 本次资源申请不成功,不予分配!!!"<<endl;cout<<endl;restoredata(i); //将改变的数据恢复;}else{ cout<<endl;cout<<"经安全性检查,系统安全,本次分配成功,且资源分配状况如下所示:"<<endl;cout<<endl;showdata();if(chkmax(i)){cout<<"在资源分配成功之后,由于该进程所需的某些资源的最大需求量已经满足,"<<endl;//cout<<"因此在进程结束后系统将回收这些资源!"<<endl;cout<<"在资源收回之后,各进程的资源需求和分配情况如下所示:"<<endl;showdata();}}}cout<<endl;cout<<" 是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ";cin>>flag;}}///////////////////////////////////银行家end//////////////////////////////////////////////void diaodu(){char ch;ch='y';while(ch=='Y'||ch=='y'){int num,m; //定义进程数printf(" 请输入创建进程数:");scanf("%d",&num);if(num<=0){printf(" 输入错误!请重新输入大于0的正整数!\n");}else{struct pro* head=(struct pro*)malloc(sizeof(struct pro));//创建链表head->next=NULL;struct pro* s;TOTALTIME=0;for(int i=0;i<num;i++){s=(struct pro*)malloc(sizeof(struct pro));printf(" 请输入进程名: ");scanf("%s",&(s->num));j: printf(" 请输入到达时间: ");scanf("%d",&(s->arriveTime));if(s->arriveTime<0){printf(" 输入错误!请重新输入大于0的正整数!\n");goto j;}k: printf(" 请输入运行时间: ");scanf("%d",&(s->burst));if(s->burst<0){printf(" 输入错误!请重新输入大于0的正整数!\n");goto k;}l: printf(" 请输入优先数: ");scanf("%d",&(s->weight));if(s->weight<0){printf(" 输入错误!请重新输入大于0的正整数!\n");goto l;}TOTALTIME+=s->burst; //计算总时间s->rt=1; //rt的初始值为1s->next=NULL;insert(head,s);}printf("\n\n***********请选择处理机调度方式***************n\n");printf("* 1.短作业优先法*\n\n");printf("* 2.优先级计算法*\n\n");printf("* 3.时间片轮转法*\n\n");printf("* 4.威武……退出!*\n\n");printf("*************************************************\n\n");x: scanf("%d",&m);if(m<1||m>4){printf(" 输入错误!请重新输入!\n");goto x;}printf("******************************************************\n");switch(m){case 1:{printf(" 短作业优先法\n");printf("******************************************************\n");run2(head);break;};case 2:{printf(" 优先级计算法\n");printf("******************************************************\n");run3(head);break;};case 3:{printf(" 时间片轮转法\n");printf(" 当前时间片大小为:%d\n",RR);printf("******************************************************\n");run(head);break;};case 4:exit(0);}printf(" 是否继续? 是:Y/y; 否:任意键!");scanf("%s",&ch);printf("******************************************************\n");}}}void main(){while(1){printf("\n\n********************请选择算法*******************\n\n");printf("* 1.时间片轮转法、短作业优先法、优先级计算法*\n\n");printf("* 2.银行家算法避免死锁*\n\n");printf("* 3.so easy的先来先服务,随机生成进程情况*\n\n");printf("* 4.威武……退出!*\n\n");printf("*************************************************\n\n");while(1){int a;scanf("%d",&a);if (a == 1){system("cls");diaodu();break;}if (a == 2){system("cls");yinhangjia();break;}if( a == 3 ){system("cls");FCFS();break;}if (a == 4)exit(0);if (a > 5 || a < 1){printf("Error,input again!");}}system("pause");system("cls");}}。
操作系统lab8

HUNAN UNIVERSITY 操作系统实验报告题目:LAB8目录一、实验目的 (3)二、实验内容 (3)三、练习题 (3)练习0 (3)练习1 (4)练习2 (10)四、实验结果 (13)一、实验目的通过完成本次实验,希望能达到以下目标了解基本的文件系统系统调用的实现方法;了解一个基于索引节点组织方式的Simple FS文件系统的设计与实现;了解文件系统抽象层-VFS的设计与实现;二、实验内容实验七完成了在内核中的同步互斥实验。
本次实验涉及的是文件系统,通过分析了解ucore 文件系统的总体架构设计,完善读写文件操作,从新实现基于文件系统的执行程序机制(即改写do_execve),从而可以完成执行存储在磁盘上的文件和实现文件读写等功能三、练习练习0:填写已有实验本实验依赖实验1/2/3/4/5/6/7。
请把你做的实验1/2/3/4/5/6/7的代码填入本实验中代码中有“LAB1”/“LAB2”/“LAB3”/“LAB4”/“LAB5”/“LAB6”/“LAB7”的注释相应部分。
并确保编译通过。
注意:为了能够正确执行lab8的测试应用程序,可能需对已完成的实验1/2/3/4/5/6/7的代码进行进一步改进将其与lab7文件对比,得到缺失文件如下:proc.cdefault_pmm.cpmm.cswap_fifo.cvmm.ctrap.csche.cmonitor.check_sync.c补全后不需要在7的基础上改了练习1: 完成读文件操作的实现(需要编码)首先了解打开文件的处理流程,然后参考本实验后续的文件读写操作的过程分析,编写在sfs_inode.c中sfs_io_nolock读文件中数据的实现代码。
请在实验报告中给出设计实现”UNIX的PIPE机制“的概要设方案,鼓励给出详细设计方案要求是首先了解打开文件的处理流程,然后参考本实验后续的文件读写操作的过程分析,编写在sfs_inode.c中sfs_io_nolock读文件中数据的实现代码。
操作系统实验指导书及代码

操作系统实验指导书及代码《操作系统》实验指导书目录实验环境 ................................................. 1 实验报告要求 ............................................. 1 实验一进程控制与处理机调度综合实验 ..................... 2 实验二存储管理与页面置换算法 (7)实验环境本课程实验硬件环境为PⅢ以上的处理器,带有显示器。
操作系统使用windows98以上操作系统,基本编程环境为Turbo C。
实验报告要求实验报告应包含以下内容:(1)实验题目(2)实验目的(3)实验环境(4)算法描述(5)程序源代码(6)出现的问题(7)对问题的解决方案(8)实验结果与结果分析(9)实验思考(学生对本次实验的收获的总结)实验一进程控制与处理机调度综合实验一、实验目的通过模拟进程控制方法及单处理机系统的进程调度,了解进程的结构,进程的创建与撤消,进程的组织及进程的状态及其转换,掌握进程调度策略。
二、实验学时4学时三、实验内容本实验为单机模拟进程调度算法,在程序设计时不需真正地建立线程或者进程。
实验模拟创建若干进程(人为输入或随机数产生),选择一种或几种单处理机的进程调度算法,如FCFS(先来先服务),SPF(短进程优先),RR(时间片轮转法),优先级算法等,模拟进行进程调度。
每进行一次调度,都打印一次运行进程、就绪队列、以及各个进程的PCB,并能在进程完成后及时撤消该进程。
四、算法描述1 进程及进程的运行状态进程是现代计算机中的基本要素,是系统分配资源和调度的基本单位。
进程与程序不同,进程是系统中动态的实体,有它的创建、运行和撤销的过程。
PCB块是系统感知进程存在的唯一实体。
进程的创建必须首先创建进程的PCB块,而进程的运行也伴随着PCB块的变化,进城撤销也要同时撤销它的PCB块。
所以本实验的任务就是通过模拟调度进程的PCB块来调度进程。
操作系统实习报告(源代码)

#define false 0#define true 1#include "stdio.h"typedef struct{char name[3]; /*文件或目录名*/char type[2]; /*文件类型名*/char attribute; /*属性*/char address; /*文件或目录的起始盘块号*/char length; /*文件长度,以盘块为单位*/}content; /*目录结构*/#define n 5 /*模拟实验中系统允许打开文件的最大数量*/typedef struct{int dnum; /*磁盘盘块号*/int bnum; /*盘块内第几项*/}pointer; /*已打开文件表中读写指针的结构*/typedef struct{char name[20]; /*文件绝对路径名*/char attribute;/*文件的属性,用1个字节表示,所以用了char类型*/int number; /*文件起始盘块号*/int length; /*文件长度,文件占用的字节数*/int flag; /*操作类型,用"0"表示以读操作方式开文件,用"1"表示写操作方式打开文件*/ pointer read; /*读文件的位置,文件刚打开时dnum为文件起始盘块号,bnum为"0"*/ pointer write; /*写文件的位置,文件建立时dnum为文件起始盘块号,bnum为"0",打开时为文件末尾*/}OFILE; /*已打开文件表项类型定义*/struct{OFILE file[n]; /*已打开文件表*/int length; /*已打开文件表中登记的文件数量*/}openfile; /*已打开文件表定义*/char buffer1[64];/*模拟缓冲1*/content buffer2[8];/*模拟缓冲2*/FILE *fc; /*模拟磁盘的文件指针*/void copen(OFILE *x1,OFILE *x2)OFILE *x1,*x2;{strcpy(x1->name,x2->name);x1->attribute=x2->attribute;x1->number=x2->number;x1->length=x2->length;x1->flag=x2->flag;x1->read.dnum=x2->read.dnum;x1->read.bnum=x2->read.bnum;x1->write.dnum=x2->write.dnum;x1->write.bnum=x2->write.bnum;}sopen(name)/*在已打开文件表中查找文件name*/char *name;{int i;i=0;while(i<openfile.length&&strcmp(openfile.file[i].name,name)!=0)/*依次查找已打开文件表*/i++;if(i>=openfile.length)return(-1);return(i);}/*查找sopen函数结束*/dopen(name)/*在已打开文件表中删除文件name*/char *name;{int i;i=sopen(name);if(i==-1)printf("文件未打开/n");else{copen(&openfile.file[i],&openfile.file[openfile.length-1]);openfile.length--;}}/*删除函数结束*/iopen(x)/*在已打开文件表中插入文件name*/content *x;{int i;i=sopen(x->name);if(i!=-1){printf("文件已经打开/n");return(false);}else if(openfile.length==n){printf("已打开文件表已满/n");return(false);}else{copen(&openfile.file[openfile.length],x);openfile.length++;return(true);}}/*填写已打开文件表函数结束*/allocate( )/*分配一个磁盘块,返回块号*/{int i;fseek(fc,0,SEEK_SET); /*将模拟磁盘的文件指针移至模拟磁盘FAT表*/fread(buffer1,64L,1,fc);/*将FAT表中第一个磁盘块读入模拟缓冲buffer1中*/for(i=3;i<63;i++)if(buffer1[i]==0){ /*FAT中的第i项为0,分配第i块磁盘块,修改FAT表,并且写回磁盘*/buffer1[i]=255;fseek(fc,0,SEEK_SET);fwrite (buffer1,64L,1,fc);return(i); /*返回磁盘号*/}fread(buffer1,64L,1,fc);/*将FAT表中第二个磁盘块读入模拟缓冲buffer1中*/for(i=0;i<63;i++)if(buffer1[i]==0){/*FAT中的第i项为0,分配第i+64块磁盘块,修改FAT表,并且写回磁盘*/ buffer1[i]=255;fseek(fc,-64L,SEEK_CUR);fwrite(buffer1,64L,1,fc);return(i+64); /*返回磁盘号*/}printf("已经没有磁盘空间/n");return(false);}/*分配磁盘块函数结束*/read_file(name,length)/*读文件函数,文件路径名name,读取长度length*/char *name;int length;{int i,t;char ch;if((i=sopen(name))==-1){printf("文件没有打开或不存在/n");return(false);}if(openfile.file[i].flag==1){printf("文件以写方式打开,不能读/n");return(false);}t=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);while(t<length&&buffer1[openfile.file[i].read.bnum]!='#'){putchar(buffer1[openfile.file[i].read.bnum]);/*读出一个字符(这里是在屏幕上显示)*/if((t+1)%64==0)putchar('/n');/*修改读指针*/openfile.file[i].read.bnum++;if(openfile.file[i].read.bnum>=64)/*一块读完,读取下一个盘块*/{fseek(fc,openfile.file[i].read.dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);openfile.file[i].read.dnum=buffer1[openfile.file[i].read.dnum%64];/*修改读指针*/openfile.file[i].read.bnum=0;fseek(fc,openfile.file[i].read.dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读取下一个*/}t++;}}/*读函数结束*/write_file(name,buff,length)/*写文件函数*/char *name;/*文件路径名*/char *buff;/*存放准备写入磁盘的内容*/int length;/*写入内容的长度*/{int i,t,dd;if((i=sopen(name))==-1)/*文件不存在,无法写*/{printf("文件没有打开或不存在/n");return(false);}if(openfile.file[i].flag==0){printf("文件以读方式打开,不能写/n");return(false);}t=0;fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);while(t<length){buffer1[openfile.file[i].write.bnum]=buff[t];openfile.file[i].write.bnum++;openfile.file[i].length++;if(openfile.file[i].write.bnum>=64){fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完,写回磁盘*/if((dd=allocate())==false){openfile.file[i].write.bnum--;openfile.file[i].length--;printf("无磁盘空间,部分信息丢失,写失败/n");return(false);}/*if*/fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.dnum%64]=dd;fseek(fc,openfile.file[i].write.dnum/64*64L, SEEK_SET);fwrite(buffer1,64,1,fc);openfile.file[i].write.dnum=dd;openfile.file[i].write.bnum=0;}/*if*/t++;}/*while*/fseek(fc, openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);/*一块写完,写回磁盘*/}/*写函数结束*/search(name,flag,dnum,bnum)/*查找路径名为name的文件或目录,返回该目录的起始盘块号*/char *name;int flag; /*flag=8表示查找目录,否则为文件*/int *dnum,*bnum;/*返回找到文件或目录的目录项的位置:盘块dnum中第bnum项*/ {int k,i,s,t,j,last=0;char pna[3],type[2];if((strcmp(name,"")==0)||(strcmp(name,"/")==0))/*根目录*/return(2);k=0;if(name[0]=='/')k=1;i=2; /*i=根目录的起始盘块号*/while(last!=1){/*pna=从name中分离出"/"后一个目录名(或文件名)*/for(s=0;name[k]!='.'&&name[k]!='/'&&s<3&&name[k]!='/0';s++,k++)pna[s]=name[k];for(;s<3;s++)/*用空格补全名字长度*/pna[s]=' ';while(name[k]!='.'&&name[k]!='/0'&&name[k]!='/')/*除去多余字符*/k++;type[0]=type[1]=' ';if(name[k]=='.')/*取文件类型名type*/if(flag==8){printf("目录不应该有有类型名,查找失败/n");return(false);}else{/*文件遇到类型名认为结束,后面的字符作废*/k++;if(name[k]!='/0')type[0]=name[k];k++;if(name[k]!='/0')type[1]=name[k];if(name[k]!='/0'&&name[k+1]!='/0'){printf("文件名错误/n");return(false);}last=1;}elseif(name[k]!='/0')k++;if(name[k]=='/0')last=1;/*查找目录且名字等于pna的目录项*/fseek(fc,i*64L,SEEK_SET);fread(buffer2,64L,1,fc);j=0;if(last==1&&flag!=8)while(j<8&&!(buffer2[j].attribute!=8&&buffer2[j].name[0]==pna[0]&&buffer2[j].name[1]==pna[1]&&buffer2[j].name[2]==pna[2]&&buffer2[j].type[0]==type[0]&&buffer2[j].type[1]==type[1]))j++;elsewhile(j<8&&!(buffer2[j].attribute==8&&buffer2[j].name[0]==pna[0]&&buffer2[j].name[1]= =pna[1]&&buffer2[j].name[2]==pna[2]))j++;if(j<8)/*找到该目录或文件*/if(last==1)/*查找结束*/{*dnum=i;*bnum=j;return(buffer2[j].address);}else/*查找还未结束*/i=buffer2[j].address;/*读取下一个盘块*/elsereturn(false);}/*while 查找结束*/}/*search()结束*/create_file(name,attribute)/*建立文件函数,路径名name,文件属性attribute*/char *name;int attribute;{int dnum,bnum,i,j,last,k,s,d,t,tt,b,dd,flag,dn,bn;char dname[3],tname[2],pathname[20];OFILE x;if(attribute%2==1){printf("只读文件,无法写,不能建立/n");return(false);}if(openfile.length==n){printf("已打开表已满,不能建立/n");return(false);}/* 将name分成两部分,目录路径pathname和目录名dname*/for(j=0;name[j]!='/0';j++)/*查找最后一个"/"*/if(name[j]=='/')s=j;/*分离目录路径*/for(j=0;j<s;j++)pathname[j]=name[j];pathname[j]='/0';/*分离文件名*/for(k=0,j=s+1;name[j]!='/0'&&k<3&&name[j]!='.';j++,k++)dname[k]=name[j];if(k==0){printf("错误文件名或目录名/n");return(false);}for(;k<3;k++)dname[k]=' ';k=0;if(name[j++]=='.')/*分离类型名*/{for(;name[j]!='/0'&&k<2&&name[j]!='.';j++,k++)tname[k]=name[j];}for(;k<2;k++)tname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径,返回该目录所在块号dn 和项数bn*/{printf("目录不存在,不能建立");return(false);}/*确认该目录不存在的同时查找空目录项*/b=-1;fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc); /*读出dnum盘块的内容*/for(t=0;t<8;t++){if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1]&&buffer2[t].name[2]== dname[2]&&buffer2[t].type[0]==tname[0]&&buffer2[t].type[1]==tname[1]){/*找到名字dname的文件,建立失败*/printf("文件已经存在,不能建立/n");return(false);}if(buffer2[t].name[0]=='$'&&b==-1)b=t;}/*for*/if(b==-1)/*没有空目录项,建立失败*/{printf("目录无空间/n");return(false);}if((dd=allocate( ))==false)/*分配给建立目录的磁盘盘块dd*/{printf("建立文件失败/n");return(false);}/*填写目录项*/for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];for(i=0;i<2;i++)buffer2[b].type[i]=tname[i];buffer2[b].attribute=attribute;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*填写已打开文件表*/strcpy(,name);x.attribute=attribute;x.number=dd;x.length=0;x.flag=1;x.read.dnum=x.write.dnum=dd;x.read.bnum=x.write.bnum=0;iopen(&x);}/*建立文件结束*/open_file(name,attribute)/*打开文件函数*/char *name;int attribute;{OFILE x;int dnum,bnum,last,i,d;if((d=search(name,4,&dnum,&bnum))==false){printf("文件不存在,打开操作失败/n");return(false);}fseek(fc,dnum*64L,SEEK_SET);/*读出对应目录项*/fread(buffer2,64,1,fc);if((buffer2[bnum].attribute%2==1)&& attribute==1)/*对只读文件要求写*/ {printf("文件不能写,打开失败");return(false);}strcpy(,name);x.attribute=buffer2[bnum].attribute;x.number=buffer2[bnum].address;x.read.dnum=x.write.dnum=buffer2[bnum].address;x.read.bnum=x.write.bnum=0;x.flag=attribute;if(attribute==1){while(d!='/xff')/*寻找文件末尾*/{fseek(fc, d/64*64L, SEEK_SET);fread(buffer1,64L,1,fc);/*读出dnum项所在FAT*/last=d;d=buffer1[d%64];/*读出dnum块下一块内容赋给dnum*/ }/*while*/x.write.dnum=last;/*填写写指针*/fseek(fc, last*64L, SEEK_SET);fread(buffer1,64L,1,fc);for(i=0;i<64&&buffer1[i]!='#';i++);x.write.bnum=i;x.length=(buffer2[bnum].length-1)*64+i;}iopen(&x);/*填写已打开文件表*/}close_file(name)/*关闭文件函数*/char *name;{int i,dnum,bnum;if((i=sopen(name))==-1){printf("打开的文件中没有该文件,关闭失败/n");return(false);}if(openfile.file[i].flag==1)/*写文件的追加文件结束符*/{fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fread(buffer1,64,1,fc);buffer1[openfile.file[i].write.bnum]='#';fseek(fc,openfile.file[i].write.dnum*64L, SEEK_SET);fwrite(buffer1,64,1,fc);fputc('#',fc);search(name,4,&dnum,&bnum);/*查找该文件目录位置*//*修改目录中的文件长度*/fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].length=openfile.file[i].length/64+1;fseek(fc, dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);}/*在已打开文件表中删除该文件的登记项*/if(openfile.length>1)copen(&openfile.file[i],&openfile.file[openfile.length-1]);openfile.length--;}delete(name)/*删除文件*/char *name;{int dnum,bnum,t;if((t=search(name,4,&dnum,&bnum))==false){printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能删除/n");return(false);}fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64,1,fc);buffer2[bnum].name[0]='$';/*将该文件的目录置成空目录*/fseek(fc,dnum*64L, SEEK_SET);fwrite(buffer2,64,1,fc);while(t!='/xff')/*通过FAT查找每一个盘块号,并依次删除*/{dnum=t;fseek(fc, dnum/64*64, SEEK_SET);fread(buffer1,64,1,fc);t=buffer1[dnum%64];buffer1[dnum%64]=0;fseek(fc, dnum/64*64L, SEEK_SET);fwrite(buffer1,64,1,fc);}}/*文件删除结束*/md(name)/*建立目录函数,目录路径名name*/char *name;{int dnum,bnum,i,j,last,k,s,d,t,tt,b,dd,flag,dn,bn;char dname[3],pathname[20];i=2;/* i=根目录的起始盘块号*//* 将name分成两部分,目录路径pathname和目录名dname*/ for(j=0;name[j]!='/0';j++)/*查找最后一个"/"*/if(name[j]=='/')s=j;/*分离目录路径*/for(j=0;j<s;j++)pathname[j]=name[j];pathname[j]='/0';/*分离目录名*/for(k=0,j=s+1;name[j]!='/0'&&k<3&&name[j]!='.';j++,k++) dname[k]=name[j];if(k==0){printf("错误文件名或目录名/n");return(false);}for(;k<3;k++)dname[k]=' ';if((d=search(pathname,8,&dn,&bn))==false)/*找到目录路径*/{printf("目录不存在,不能建立/n");return(false);}b=-1;/*确认该目录不存在的同时查找空目录项*/fseek(fc,d*64L,SEEK_SET);fread(buffer2,64L,1,fc);/*读出d盘块的内容*/for(t=0;t<8;t++){if(buffer2[t].name[0]==dname[0]&&buffer2[t].name[1]==dname[1] &&buffer2[t].name[2]==dname[2]&&buffer2[t].attribute==8) {/*找到名字dname的目录,建立失败*/printf("目录已经存在,不能建立/n");return(false);}if(buffer2[t].name[0]=='$'&&b==-1)b=t;}/*for*/if(b==-1)/*没有空目录项,不能建立*/{printf("目录无空间/n");return(false);}if((dd=allocate( ))==false)/*分配给建立目录的磁盘盘块dd*/{printf("目录不能建立/n");return(false);}/*填写目录项*/for(i=0;i<3;i++)buffer2[b].name[i]=dname[i];buffer2[b].type[0]=buffer2[b].type[1]=' ';buffer2[b].attribute=8;buffer2[b].address=dd;buffer2[b].length=0;fseek(fc,d*64L,SEEK_SET);fwrite(buffer2,64L,1,fc);/*分给新建目录的盘块初始化*/for(t=0;t<8;t++)buffer2[t].name[0]='$';fseek(fc, dd*64L, SEEK_SET);fwrite(buffer2,64L,1,fc);}/*建立目录结束*/dir(name)/*显示目录内容*/char *name;{int i,bnum,t,tt,dnum,dn,bn;if((dnum=search(name,8,&dn,&bn))==false)/*找到目录路径,返回该目录所在块号dn和盘块内项数bn*/{printf("目录不存在/n");return(false);}printf("名称扩展名起始盘块长度/n");/*显示目录内容*/fseek(fc,dnum*64L, SEEK_SET);fread(buffer2,64L,1,fc);for(t=0;t<8;t++)/*显示该盘块中目录项的内容*/if(buffer2[t].name[0]!='$')printf(" %c%c%c %c%c %4d%7d/n", buffer2[t].name[0], buffer2[t].name[1],buffer2[t].name[2], buffer2[t].type[0], buffer2[t].type[1],buffer2[t].address, buffer2[t].length);}/*显示目录函数结束*/typefile(name)/*显示文件内容*/char *name;{int i,dnum,dn,bn,t;if((dnum=search(name,1,&dn,&bn))==false){printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能显示/n");return(false);}while(dnum!='/xff'){fseek(fc,dnum*64L,SEEK_SET);fread(buffer1,64,1,fc);/*读一个盘块到缓冲*/for(t=0;t<64&&buffer1[t]!='#';t++)/*显示缓冲中内容*/ putchar(buffer1[t]);printf("/n");/*获得下一个盘块*/fseek(fc, dnum/64*64L, SEEK_SET);fread(buffer1,64,1,fc);dnum=buffer1[dnum%64];}}/*显示文件函数结束*/change(name,attribute)/*改变文件name的属性为attribute*/char *name;int attribute;{int dnum,bnum;if(search(name,1,&dnum,&bnum)==false)/*查找文件目录*/ {printf("文件不存在/n");return(false);}if(sopen(name)!=-1){printf("该文件打开,不能改变文件属性/n");return(false);}fseek(fc,dnum*64L,SEEK_SET);fread(buffer2,64,1,fc);/*读出该目录所在盘块*/buffer2[bnum].attribute=attribute;/*修改属性*/fseek(fc,dnum*64L,SEEK_SET);fwrite(buffer2,64,1,fc);/*写回磁盘*/}/*改变文件属性函数结束*/main( ){char name[20];int attribute,type,length,i,a,j;char buffer[64];/*建立文件,模拟磁盘*/if((fc=fopen("c://os//c","w+"))==NULL){printf("无法打开文件/n");exit(0);}/*初始化已打开文件表*/openfile.length=0;/*初始化磁盘*//*初始化文件分配表*/buffer1[0]=buffer1[1]=buffer1[2]=255;/*磁盘第0、1块存放FAT表,第2块存放跟目录*/for(i=3;i<64;i++)buffer1[i]=0;buffer1[13]=buffer1[49]=254;/*假定模拟磁盘中有两个坏盘块:第13块和49块*/fwrite(buffer1,64L,1,fc);for(i=0;i<64;i++)buffer1[i]=0;fwrite(buffer1,64L,1,fc);/*初始化根目录*/for(i=0;i<8;i++)buffer2[i].name[0]='$';/*若目录项的第一个字符为"$"表示该目录项为空*/ fwrite(buffer2,64L,1,fc);/*初始化已打开文件表*/while(1){printf("/n 0 - 结束/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~9):");scanf("%d",&a);switch(a){case 0: /*a=0程序结束*/fclose(fc);exit(0);case 1: /*a=1建立文件*/printf("输入文件路径名和文件属性(1-只读文件,3-只读系统文件,4-普通文件):");scanf("%s%d",name,&attribute);create_file(name,attribute); /*建立文件*/break;case 2: /*a=2打开文件*/printf("输入文件路径名和操作类型(0-读文件,1-写文件):");scanf("%s%d",name,&type);open_file(name,type); /*打开文件*/break;case 3: /*a=3读文件*/printf("输入文件路径名和读长度");scanf("%s%d",name,&length);read_file(name,length); /*读文件*/break;case 4: /*a=4写文件*/printf("输入文件路径名:");scanf("%s",name);printf("输入写的内容和和写长度");scanf("%s%d",buffer,&length);write_file(name,buffer,length); /*写文件*/break;case 5: /*a=5关闭文件*/printf("输入文件路径名");scanf("%s",name);close_file(name); /*关闭文件*/break;case 6: /*a=6删除文件*/printf("输入文件路径名");scanf("%s",name);delete(name); /*删除文件*/break;case 7: /*a=7建立目录*/printf("输入目录路径名");scanf("%s",name);md(name); /*建立目录*/break;case 8: /*a=8显示目录*/printf("输入目录路径名");scanf("%s",name);dir(name); /*显示目录*/break;case 9: /*a=9显示文件*/printf("输入文件路径名");scanf("%s",name);typefile(name); /*显示文件*/break;case 10:/* a=10改变文件属性*/printf("输入文件路径名和文件属性(1-只读文件,3-只读系统文件,4-普通文件):");scanf("%s%d",name,&attribute);change(name,attribute);}/* switch */}/* while */}/*main( )结束*/。
大连理工大学操作系统实验报告(附代码)

//初始化套接字库 //创建 TCP 套接字
//初始化地址结构
while(1){ if(::bind(link, (sockaddr*)&addr1, sizeof(addr1)) == 0){ ::listen(link, 5); cout<<"你已成功启动.\n"; break; }else{ addr1.sin_port = htons(++port); } } HANDLE h1 = ::CreateThread(NULL,0,fx1,NULL,0,NULL);
2.WinSock #include <iostream> #include <stdio.h> #include <windows.h> using namespace std; DWORD WINAPI fx1(LPVOID lp); DWORD WINAPI fx2(LPVOID lp); SOCKET link,sender,s; sockaddr_in addr1,addr2; int port = 75; char* friendIp; bool connected = false; bool connecting = false; bool close = false; int main() { friendIp = new char[20]; WSAData data; WORD wVersion = MAKEWORD(2,0); ::WSAStartup(wVersion, &data); link = ::socket(AF_INET,SOCK_STREAM,0); s = ::socket(AF_INET, SOCK_STREAM, 0); addr1.sin_family = AF_INET; addr1.sin_port = htons(port); addr1.sin_addr.S_un.S_addr = INADDR_ANY;
操作系统实验代码1

prioChangerun()
{
while(run!=NULL)
{
if(run->res==run->runTime)
{
if(resource.free==1)
{
resource.pid=run->pid;
ready=NULL;
finish=NULL;
run=NULL;
wait=NULL;
printf("Enter name and run time of each process:(eg.pid1[press ENTER]100)\n");
for(i=1;i<=N;i++)
{
return 1+(int)((to)*rand()/(RAND_MAX+from));
}
runIn()
{
run=ready;
run->status=1;
} ready=ready->next;
readyIn()
{
{
if(run->prio<20)
run->prio+=1;
}
void changeReadyPrio()
{
PCB *p;
p=ready;
if(p!=NULL)
{
do
{
if(p->type==0)
printf("pid name status type prio res tatalTime count runTime\n");
}
北邮操作系统进程管理实验报告及源代码

进程管理实验报告1. 实验目的:(1)加深对进程概念的理解, 明确进程和程序的区别;(2)进一步认识并发执行的实质;(3)分析进程争用资源的现象, 学习解决进程互斥的方法;(4)了解Linux系统中进程通信的基本原理。
2. 实验预备内容(1)阅读Linux的sched.h源码文件, 加深对进程管理概念的理解;(2)阅读Linux的fork()源码文件, 分析进程的创建过程。
3.环境说明本次实验使用的是win7下的VMWare workstation虚拟机, 安装了ubuntu系统在ubuntu系统下使用code::blocks IDE编写代码并执行程序的4.实验内容:1.进程的创建:(1)实验题目和要求:编写一段程序, 使用系统调用fork() 创建两个子进程。
当此程序运行时, 在系统中有一个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:父进程显示字符“a”, 子进程分别显示字符“b”和“c”。
试观察记录屏幕上的显示结果, 并分析原因。
(2)程序设计说明:参照书上的例子进行设计, 详见源代码(3)程序运行结果截图:(4)程序分析:a,b,c随机出现, 因为父进程与两个子进程之间并没有同步措施, 所以a,b,c随机打印出来, 也就是三个进程的活动次序是随机进行的, 不同的系统可能有不同的进程调度方式。
(5)源程序:#include<sys/types.h>#include<stdio.h>#include<unistd.h>int main(){pid_t pid1,pid2;if((pid1=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid1=fork())==0)printf("b\n");else{if((pid2=fork())<0){printf("Fork Failed.\n");exit(-1);}else if((pid2=fork())==0)printf("c\n");else{wait(NULL);printf("a\n");exit(0);}}return 0;}2.进程的控制:要求一:(1)实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。
操作系统实验实验报告-阅读Windows工作集管理相关代码

操作系统实验实验报告班号:姓名:学号:实验日期: 2011.11. 实验名称:阅读Windows工作集管理相关代码一、实验目的分析工作集管理代码,熟悉工作集管理算法二、实验要求阅读工作集管理代码,给出工作集管理中设置重要参数(如项目1中工作集最小值和最大值,峰值等)的代码,给出工作集管理流程图和算法描述三、实验过程及结果1)工作集管理部分的代码相应分成以下五个模块,MmWorkingSetManager()MiComputeSystemTrimCriteria ()//工作集管理线程MI_AGE_ALL_WORKING_SETSMiProcessWorkingSets()MiTrimWorkingSet()////根据MI_TRIM_ALL_WORKING_SETS确定剪支MiAgeWorkingSet ()//根据MI_AGE_ALL_WORKING_SETS判断是否老化2)根据阅读代码情况,总结Windows的近似LRU算法原理与步骤。
工作集结构图四、实验分析MiTrimWorkingSet()函数原型:MiTrimWorkingSet (WSLE_NUMBER Reduction,PMMSUPPORT WsInfo, ULONG TrimAge)参数说明:IN WSLE_NUMBER Reduction,需要修建的页面数目IN PMMSUPPORT WsInfo,进程工作集指针IN ULONG TrimAge,需要修剪的页面的年龄限值变量说明:WsleFlushList:存放将要移除的页面索引和数目,TryToFree;StartEntry;LastEntry;这三个整型变量遍历Wsle数组确定修剪的页面。
WorkingSetList工作集链表指针Wsle:工作集页面指针PointerPte,当前页面的PTE结构指针NumberLeftToRemove本次过程结束后未被移除的页面数目NumberNotFlushed:调用MiFreeWsleList后未被移除的页面数目确定在Wsle中搜索的起始位置TryToFree和结束位置StartEntry-1,TrimMore程序段,本程序段主要根据最近最久未使用算法,对工作集页面数组Wsle从TryToFree开始循环搜索移除页面,并调用MiFreeWsleList释放相应页面。
计算机操作系统实验指导汤小丹版源代码

计算机操作系统实验指导汤小丹版源代码```python#实验指导:操作系统进程调度算法实现#题目描述:#设计一个操作系统的进程调度算法,使得CPU能够合理地分配给各个进程时间片,并实现算法的模拟。
#要求:#1.设计进程调度算法#2.实现进程控制块#3.实现模拟CPU的运行过程#实验步骤:#1.定义进程控制块#进程控制块(PCB)存储了一个进程的相关信息,包括进程ID、优先级、进程状态等等。
以下是一个简单的PCB类的定义:class PCB:def __init__(self, pid, priority):self.pid = pidself.priority = priorityself.state = 'ready'#2.实现进程调度算法# 进程调度算法决定了CPU如何从就绪队列中选择下一个要执行的进程。
以下是一个简单的调度算法(Round-Robin算法)的实现:def schedule(processes):while True:for process in processes:if process.state == 'ready':print(f"Running process {process.pid}...")process.state = 'running'#3.实现CPU的模拟#在模拟CPU运行过程中,可以将每个进程表示为一个线程,通过调度算法选择要运行的线程,并模拟线程执行的过程。
import threadingclass CPU(threading.Thread):def __init__(self, process):threading.Thread.__init__(self)self.process = processdef run(self):print(f"CPU: Running process {self.process.pid}...")print(f"CPU: Process {self.process.pid} finished.") self.process.state = 'finished'#4.实验结果展示#定义几个进程process1 = PCB(1, 1)process2 = PCB(2, 2)process3 = PCB(3, 3)#将进程放入就绪队列processes = [process1, process2, process3]#调度进程schedule(processes)#模拟CPU运行for process in processes:cpu = CPU(process)cpu.startcpu.join#5.实验总结# 本次实验基于Python语言,实现了一个简单的操作系统进程调度算法模拟。
操作系统实验代码2

}
else
{
p->type=1;
p->prio=randomPrio(11.0,19.0);
}
p->res=time/2;
p->totalTime=time;
p->count=0;
p=malloc(sizeof(PCB));
p->pid=1000+i;
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->status=2;
if(i%2==0)
{
p->type=0;
}
p=finish;
if(p!=NULL)printf("Finished.............\n");
while(p!=NULL)
{
print2(p);
p=p->next;
}
print1();
}
insertReady(PCB *p2)
{
tail->next=p2;
}
}
if(run->runTime>=run->totalTime)
{
if(run->pid==resource.pid)
{
resource.free=1;
if(wait!=NULL)
{
PCB *p=wait;
ready=NULL;
操作系统实验代码

#include "stdlib.h"#include "stdio.h"#include "time.h"typedef struct node{int data;int same;struct node *next;}linklist;FILE *fp;void optimal(int a[20],int m);void fifo(int a[20],int m);void lru(int a[20],int m);void list(linklist*h);void main( void ){int i,j=0,m,a[20];printf("产生一个20个10以内的数组成的随机序列:\n");srand( (unsigned)time( NULL ) );//使得每次产生的随机数不同 fp = fopen("D:\\缺页置换算法.txt","w");fprintf(fp,"******************************缺页置换算法**************************\n");for( i = 0; i < 20;i++ ){a[j]=rand();j++;}fprintf(fp,"随机产生的数为:\n");for (i=0;i<20;i++){printf("%d\t",a[i]);fprintf(fp,"%d\t",a[i]);}printf("请输入进程所分配的物理块的数量:\n");fprintf(fp,"\n请输入进程所分配的物理块的数量:\n");scanf("%d",&m);printf("采取最佳置换算法:\n");fprintf(fp,"采取最佳置换算法:\n");optimal(a,m);printf("采取先进先出页面置换算法:\n");fprintf(fp,"采取先进先出页面置换算法:\n");fifo(a,m);printf("采取最近最久未使用置换算法:\n");fprintf(fp,"采取最近最久未使用置换算法:\n");lru(a,m);fclose(fp);}void optimal(int a[20],int m){int i,j,b[20],t=0,flag=0;int change=0,que=0;linklist *h,*p,*s,*r,*f;for(i=0;i<20;i++)b[i]=10000;//先找出数组中的每一个数的下一个相同数的对应位置for (i=0;i<20;i++){for (j=i+1;j<20;j++){if (a[i]==a[j]){b[i]=j;break;}}}//初始化链表:h=(linklist*)malloc(sizeof(linklist));p=h;for (i=0;i<m-1;i++){(*p).data=-1;// 初始化链表,-1表示该结点的数据域为空 (*p).same=10000;//printf("%d ",(*p).data);s=(linklist*)malloc(sizeof(linklist));p->next=s;p=p->next;}(*p).data=-1;(*p).same=10000;p->next=h;list(h);printf("\n");printf("\n");i=0;p=h;s=h;r=h;while (t<=19){flag=0;do//判断页面是否在内存中{if (a[i]==(*p).data)flag=1;p=p->next;}while(p!=h);if (flag==0)//flag=0表示不在内存中{if (s->data==-1)//如果指针所指向的内容为空,则直接进入{(*s).data=a[i];(*s).same=b[i];}else{f=r;do{if (((*r).same)<(*(r->next)).same)//找出最远的替换f=r->next;r=r->next;}while(r->next!=h);(*f).data=a[i];(*f).same=b[i];change++;}s=s->next;//指针右移一次que++;}i++;t++;list(h);printf("\n");}printf("缺页次数:%d\n",que);printf("置换次数:%d\n",change);fprintf(fp,"缺页次数:%d\n",que);fprintf(fp,"置换次数:%d\n",change);}void fifo(int a[20],int m){int i,flag=0,t=0;int change=0,que=0;linklist *h,*p,*s,*r;h=(linklist*)malloc(sizeof(linklist));p=h;for (i=0;i<m-1;i++){(*p).data=-1;// 初始化链表,-1表示该结点的数据域为空 //printf("%d ",(*p).data);s=(linklist*)malloc(sizeof(linklist));p->next=s;p=p->next;}(*p).data=-1;p->next=h;list(h);printf("\n");i=0;p=h;s=h;while (t<=19){flag=0;do{if (a[i]==(*p).data)flag=1;p=p->next;}while(p!=h);if (flag==0){if (s->data==-1){(*s).data=a[i];}else{(*s).data=a[i];change++;}s=s->next;que++;}i++;t++;list(h);printf("\n");}printf("缺页次数:%d\n",que);printf("置换次数:%d\n",change); fprintf(fp,"缺页次数:%d\n",que);fprintf(fp,"置换次数:%d\n",change);}void lru(int a[20],int m){int i,flag=0,t=0;int change=0,que=0;linklist *h,*p,*s,*r,*q,*c;h=(linklist*)malloc(sizeof(linklist));p=h;for (i=0;i<m-1;i++){(*p).data=-1;// 初始化链表,-1表示该结点的数据域为空 //printf("%d ",(*p).data);s=(linklist*)malloc(sizeof(linklist));p->next=s;p=p->next;}(*p).data=-1;//printf("\n%d\n", p->data);p->next=h;list(h);//return;printf("\n");i=0;//p=h;s=h;r=h;while (t<=19){p=h;flag=0;do{if (a[i]==(*p).data)//p记住重复结点的位置{flag=1;break;}p=p->next;//printf("****\n");}while(p!=h);//printf("===========%d=========",(*p).data); if (flag==0){if (s->data==-1)(*s).data=a[i];else{(*s).data=a[i];change++;}s=s->next;que++;}else{if (s->data==-1){t++;i++;continue;}if (p->next == s){t++;i++;continue;}if (s->data==p->data)s=s->next;else{r=h;while (r->next != s)//找到s的前趋r {r=r->next;//printf("++++\n");}if (r->data==a[i]){t++;i++;s=s->next;continue;}else{c = h;while(c->next != p)//找到p的前趋c c = c->next;r->next=p;//调换位置c->next=p->next;p->next=s;}}}i++;t++;list(h);printf("\n");}printf("缺页次数:%d\n",que);printf("置换次数:%d\n",change);fprintf(fp,"缺页次数:%d\n",que);fprintf(fp,"置换次数:%d\n",change);}void list(linklist*h){int i=1;linklist *p;p=h;if(!p){printf("该链表是空的。
操作系统实验代码

//int c;
scanf("%d",&task_num); //任务数
tasks=(task *)malloc(task_num *sizeof(task));
//while((c=getchar())!='\n' && c!=EOF); //清屏
{ //按调度算法选择线程
pthread_mutex_unlock(&proc_wait[curr_proc]); //唤醒
pthread_mutex_lock(&main_wait); //主线程等待
}
else
{ //无可运行任务,选择闲逛线程
pthread_mutex_unlock(&idle_wait);
for(bpp=bp;bpp->m_size;bpp++)
{
if(bpp->m_size > s)
{
a=bpp->m_addr;
s=bpp->m_size;
bp=bpp;
}
}
bp->m_addr += size;
if((bp->m_size -= size)==0)
{
do
{
bp++;
(bp-1)->m_addr=bp->m_addr;
int ci; //任务处理时间
int ti; //任务发生周期
int ci_left;
int ti_left; //record the reduction of ti \ci
操作系统文件系统实验报告后附源代码

操作系统文件系统实验报告后附源代码目录1 课程设计简介 (1)课程设计的目的 (1)课程设计内容 (1)2 数据结构的设计 (2)预定义 (2)结构体 (2)全局变量和函数 (2)3 功能模块(或算法)描述 (3)模块划分 (4)模块流程图 (6)4 程序运行结果 (4)5心得体会 (5)参考文献 (6)附源代码 (7)1 课程设计简介课程设计的目的课程设计目的使学生熟悉文件管理系统的设计方法;加深对所学各种文件操作的了解及其操作方法的特点。
通过模拟文件系统的实现,深入理解操作系统中文件系统的理论知识, 加深对教材中的重要算法的理解。
同时通过编程实现这些算法,更好地掌握操作系统的原理及实现方法,提高综合运用各专业课知识的能力。
课程设计内容课程设计内容设计一个简单的多用户文件系统。
即①在系统中用一个文件来模拟一个磁盘;②此系统至少有:Create、delete、open、close、read、write 等和部分文件属性的功能。
③实现这个文件系统。
④能实际演示这个文件系统。
基本上是进入一个界面(此界面就是该文件系统的界面)后,可以实现设计的操作要求。
1)设计一个10个用户的文件系统,每次用户可保存10个文件,一次运行用户可以打开5个文件。
2)程序采用二级文件目录(即设置主目录MFD)和用户文件目录(UFD)。
另外,为打开文件设置了运行文件目录(AFD)。
3)为了便于实现,对文件的读写作了简化,在执行读写命令时,只需改读写指针,并不进行实际的读写操作。
4)因系统小,文件目录的检索使用了简单的线性搜索。
5)文件保护简单使用了三位保护码:允许读写执行、对应位为1,对应位为0,则表示不允许读写、执行。
6)程序中使用的主要设计结构如下:主文件目录和用户文件目录(MFD、UFD),打开文件目录(AFD)即运行文件目录,如图所示。
2 数据结构的设计预定义#define BLOCKSIZ 512Login 登录结束是,登录成功输入用户名查找是否有改用户名输入密码是否密码是否正确否Inode 位图是否加锁否,加锁Inode 空间是否已满否在ionde 位图顺序查找空闲的inode 找到返回inode 地址Inode 位图解锁结束申请失败是找不到Balloc(int k)申请k 个block 空间Block 位图是否加锁否,加锁是否有k 个空闲的block 是在block 位图按照分组查找空闲的block 找到返回block 地址Block 位图解锁结束申请失败否找不到后在连续出版物:[序号]主要责任者.文献题名[J ].刊名,出版年份,卷号(期号):起止页码)[2] 刘国钧,王连成.图书馆史研究[M].北京:高等教育出版社,1979:15-18,31.(专著:[序号]主要责任者.文献题名[M].出版地:出版者,出版年:起止页码.)[3] 孙品一.高校学报编辑工作现代化特征[C].中国高等学校自然科学学报研究会.科技编辑学论文集(2).北京:北京师范大学出版社,1998:10-22.(论文集:[序号]主要责任者.文献题名[C]∥主编.论文集名.出版地:出版者,出版年:起止页码.)附:源代码#include <>#include <>#include <>#include <>#include <>#include <>#define BLOCKSIZ 512 ...............\n");login();showhelp();printf("%s>",cmdhead);while(1){scanf("%s",&str);if(strcmp(str,"exit")==0){fclose(fd);return;}else if(strcmp(str,"dir")==0) {showdir();}else if(strcmp(str,"bit")==0) {showbitmap();}else if(strcmp(str,"help")==0) {showhelp();}else if(strcmp(str,"logout")==0) {logout();}else if(Iscmd(str)){scanf("%s",&strname);cmd_Up(str,strname);}else{printf("错误命令!\n");}printf("%s>",cmdhead);}}s_r_blocks_count=0; /* 保留的 blocks 计数 */filsys. s_free_blocks_count=DATABLKNUM-5; /* 空闲的 blocks 计数 */[0]=50-5;_name, ".");dir_buf[0].d_ino= 0;_name,"..");dir_buf[1].d_ino= 0;_name, "etc");dir_buf[2].d_ino = 1;_name, ".");dir_buf[0].d_ino = 1;strcpy(dir_buf[1].d_name, "..");dir_buf[1].d_ino = 0;strcpy(dir_buf[2].d_name, "passwd");dir_buf[2].d_ino = 2;strcpy(dir_buf[3].d_name, "admin");dir_buf[3].d_ino = 3;strcpy(dir_buf[4].d_name, "xiao");dir_buf[4].d_ino = 4;fseek(fd, DATASTART+BLOCKSIZ, SEEK_SET);fwrite (dir_buf, BLOCKSIZ,1,fd);_name, ".");dir_buf[0].d_ino = 3;strcpy(dir_buf[1].d_name, "..");dir_buf[1].d_ino = 1;fseek(fd, DATASTART+BLOCKSIZ*3, SEEK_SET);fwrite (dir_buf, BLOCKSIZ,1,fd);_name, ".");dir_buf[0].d_ino =4;strcpy(dir_buf[1].d_name, "..");dir_buf[1].d_ino = 1;fseek(fd, DATASTART+BLOCKSIZ*4, SEEK_SET); fwrite (dir_buf, BLOCKSIZ,1,fd);_uid= 1;passwd[0].p_gid = GRUP_0; sername, "admin"); strcpy(passwd[0].password, "admin"); passwd[1].p_uid= 2;passwd[1].p_gid = GRUP_1;strcpy(passwd[1].username, "xiao");strcpy(passwd[1].password, "xiao");for (i=2; i<="" p="">{passwd[i].p_uid = 0;passwd[i].p_gid = GRUP_4;strcpy(passwd[i].username, "no this user"); strcpy(passwd[i].password,"");}fseek(fd,DATASTART+BLOCKSIZ*2, SEEK_SET); fwrite(passwd,BLOCKSIZ,1,fd);ininode->di_ino=2;.\n");fd = fopen (fsystemname, "rb+");_uid!=0) {sername,&pwd[i].password);}}inodetemp=read_inode(0);t\t\t\tinode %d\n",dir_buf[i].d_ino);}else if(i==1){printf("\t..\t\t\t\tinode %d\n",dir_buf[i].d_ino);}else{inodetemp=read_inode(dir_buf[i].d_ino);if((inodetemp->di_mode&DIMODE_DIR)==DIMODE_DIR){printf("\t%s\t\t\t\tinode %d\n",dir_buf[i].d_name,dir_buf[i].d_ino);}elseif((inodetemp->di_mode&DIMODE_FILE)==DIMODE_FILE) {printf("\t%s\t\t\t\tsize %d block %d\n",dir_buf[i].d_name,inodetemp->di_size,inodetemp->di_block[0]);}else{printf("\t%s\t\t\tinode %d block %d\n",dir_buf[i].d_name,dir_buf[i].d_ino,inodetemp->di_bl ock[0]);}}}}int Enterdir(char* namestr),namestr)==0){i=0;break;}if(strcmp("..",namestr)==0){i=1;break;}if(strcmp(dir_buf[i].d_name,namestr)==0) {if(dir_buf[i].d_ino!=-1){_ino);break;}}i++;}while(idi_number);if(i==cur_inode->di_number){_ino);}int Iscmd(char cmd[10]){del")==0){if(strcmp(cmdhead,"root")!=0){i=0;while(cmdhead[i]!='\0'){if(cmdhead[i]=='\\'){itemp=i;}i++;}cmdhead[itemp]='\0';}}else if(strcmp(strname,".")!=0){strcat(cmdhead,"\\");strcat(cmdhead,strname);}}else{printf("进入目录失败!\n");}}else if(strcmp(str,"create")==0){if(creat(strname)){del_ino=inum;_name,strname);fseek(fd,DATASTART+BLOCKSIZ*cur_inode->di_block[0], SEEK_SET);_name,".");buf[0].d_ino= inum;_name,"..");buf[1].d_ino= cur_inode->di_ino;fseek(fd,DATASTART+BLOCKSIZ*bnum,SEEK_SET);_ino=inum;_name,strname);fseek(fd,DATASTART+BLOCKSIZ*cur_inode->di_block[0],SEEK_SET);_name,strname)!=0){i++;}for(;idi_number;i++){strcpy(dir_buf[i].d_name,dir_buf[i+1].d_name);dir_buf[i].d_ino=dir_buf[i+1].d_ino;}cur_inode->di_number--;fseek(fd,DATASTART+BLOCKSIZ*cur_inode->di_block[0],SEEK_SET);_name,strname)==0){if(dir_buf[i].d_ino!=-1){printf("已经找到 %s ,inode=%d\n",strname,dir_buf[i].d_ino);printf("请输入新的文件名:");fflush(stdin);scanf("%s",temp);if(strlen(temp)>=14){printf("新文件名过长!重命名失败!\n");return -1;}else{if(Fd_dirfile(temp)!=-1)_name,temp);fseek(fd,DATASTART+BLOCKSIZ*cur_inode->di_block[0], SEEK_SET);sername);if(strcmp(pwd[i].username,str)==0){break;}if(strcmp("exit",str)==0){exit(0);}}if(i!=PWDNUM){break;}}while(1);printf("passwd:");fflush(stdin);scanf("%s",str);if(strcmp(pwd[i].password,str)==0){break;}if(strcmp("exit",str)==0){exit(0);}}while(1);cur_user=&pwd[i];inodetemp=read_inode(0);sername);else if(inodetemp->di_gid==1)printf("由%s创建,属于普通用户组\n",pwd[inodetemp->di_uid-1].username); }。
操作系统实验源代码

#include "iostream.h"typedefstructpcb{char name[10]; //进程名char state; //状态w(就绪)r(运行)f(结束)int id; //id号int super; //优先级intntime; //需运行的时间intrtime; //已运行的时间structpcb *next;}*pcb1;pcb1s,w;voidinit(pcb1 &r){r=NULL;}void print(){pcb1 p;cout<<"您现在查看的是就绪队列的信息:" <<endl;cout<<"进程号"<<"进程名"<<"优先级"<<"状态"<<"已运行时间"<<"需运行时间"<<endl;for(p=s;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<" "<<p->rtime<<" "<<p->ntime<<endl; }}void print1(){pcb1 p;cout<<"您现在查看的是阻塞队列的信息";cout<<"进程号"<<"进程名"<<"优先级"<<"状态(w,r,f)"<<"已运行时间"<<"需运行时间"<<endl;for(p=w;p!=NULL;p=p->next){cout<<p->id<<" "<<p->name<<" "<<p->super<<" "<<p->state<<" "<<p->rtime<<" "<<p->ntime<<endl; }}int empty(pcb1 &r){if(r==NULL)return 0;elsereturn 1;}int check(){pcb1 p;p=s;if(p->rtime==p->ntime){p->state='F';cout<<"进程"<<p->id<<" 已经结束"<<endl;return 0;}elsereturn 1;}void sort(pcb1 &r,pcb1 p) {pcb1 p1,p2;int in=0;if(r==NULL){r=p;}else{if(p->super>=r->super) {p->next=r;r=p;}else{p1=r;p2=r->next;if(p2==NULL){r->next=p;}else{while(in==0&&p2!=NULL) {if(p->super>=p2->super) {p->next=p2;p1->next=p;in=1;}else{p1=p1->next;p2=p2->next;}}}if(in==0)p1->next=p;}}void block(){if(empty(s)){if(s->next==NULL){sort(w,s);s=s->next;}else{pcb1 p1;p1=s;s=s->next;p1->next=NULL;sort(w,p1);}}else{cout<<"现在就绪队列已经为空,再没有进程需要阻塞!"<<endl; } }void wake(){if(empty(w)){pcb1 p1;p1=w;w=w->next;p1->next=NULL;sort(s,p1);}else{cout<<"阻塞队列已经为空,没有进程再需要唤醒!"<<endl; }}voidruning(){if(empty(s)){pcb1 p;p=s;if(check()){s=s->next;p->rtime++;p->super--;p->next=NULL;sort(s,p);}else{s=s->next;}}else{cout<<"就绪队列已经为空!"<<endl; }}void input(){pcb1 p2;p2=new pcb;cout<<"请输入进程号、进程名、进程优先级、需要运行时间"<<endl; cin>>p2->id>>p2->name>>p2->super>>p2->ntime;p2->rtime=0;p2->state='W';p2->rtime=0;p2->next=NULL;sort(s,p2);}void main(){charch;init(s);init(w);cout<<"**************进程调度模拟程序开始**************"<<endl; cout<<"*** w->唤醒进程***"<<endl; cout<<"*** r->运行进程***"<<endl; cout<<"*** z->阻塞进程***"<<endl; cout<<"*** q->退出程序***"<<endl; cout<<"*** c->创建进程***"<<endl; cout<<"*** s->查看就绪进程***"<<endl;cout<<"*** l->查看阻塞队列***"<<endl; cout<<"************************************************"<<endl; while(ch!='q'){cout<<"请选择功能(w,r,z,q,c,s,l):"<<endl;cin>>ch;switch(ch){case 'c':input(); break;case 'r':runing(); break;case 's':print(); break;case 'w':wake(); break;case 'l':print1(); break;case 'z':block(); break;}}}。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
j = i;
r = rand() % 100;
if (r < t)
q = rand() % N;
else
q = (q + 1) % N;
}
}
//随机生产是否被修改的情况,prop(0...100),prop/100 的概率未被修改
void generate_modify(int *mo, int e, int prop)
}
printf("\n");
for(i=0;i<9;i++)//从小到大排列磁盘号
{
for(j=i+1;j<9;j++)//从第二位开始
{
if(b[i]>b[j])//如果前一个大于后一个,两者交换
{
nin = 0;
int i, j;
for(i = 0;i < M;i++)
{
b_clock[i].num = -1;
b_clock[i].visit = 0;
}
for(i = 0;i < M;i++)
{
for(j = 0;j < N;j++)
{
{
printf("%d->",b[j]);
}
printf("0->");//已经到达最外磁道
for(j=n+1;j<8;j++)//磁头方向变为从外向里运动
{
if(a[0]==b[i])
{
n=i;//记录a[0]即53在b数组的位置
printf("The way:");
for(j=n;j>=0;j--)//找到离53外面最近的磁道
cout<<"5 scan"<<endl;
cout<<"6 FCFS"<<endl;
}
//scan******************************************************************
int a[9]={53,98,183,37,122,14,124,65,67} ;
printf(" ");
for (i = 1;i < e;i++)
printf(" ");
printf(" \n");
}
//结果输出
void print(int e,int *a)
{
int j, i;
print_format(e);
for(j = 0;j < e;j++)
printf("The way:");
for(j=n;j<9;j++)//找到离53里面最近的磁道
{
printf("%d->",b[j]);
}
printf(" %c ",' ');
else
printf(" %2d ",c[i][j]);
}
printf(" \n");
}
print_format(e);
}
//Clock 算法初始化
void Init_Clock(Page_clock *b_clock)
if(l==3)
break;
}
}
//clock*******************************************************************
#define M 3 //内存物理块数
#define N 20 //虚拟内存尺寸
int P; //工作集的起始位置
void SCAN(int l)
{
int i,j;
int m;//中间量
int n;
int sum;
int b[9]={0,0,0,0,0,0,0,0,0};
for(i=0;i<9;i++)
{
b[i]=a[i];//获取a的数组元素
#include <functional>
#include "basic.h"
using namespace std;
void Show()
{
cout<<"1 创建进程"<<endl;
cout<<"2 撤销进程"<<endl;
cout<<"3 P.V原语实现"<<endl;
cout<<"4 clock置换"<<endl;
for(i = 0;i < M;i++)
{
if (i != val)
{
b_clock[i].visit = 0;
}
}
}
else
{
nin++;
//初始化内存
for (i = 0;i < M;i++)
{
if (b_clock[i].num == -1)
}
b_clock[val].num = fold;
b_clock[val].visit = 1;
for(i = 0;i < M;i++)
}
}
}
if(l==2)
{
for(i=0;i<9;i++)
{
if(a[0]==b[i])
{
n=i;//记录a[0]即53在b数组的位置
int nin; //记录缺页次数
//用于CLOCK 算法的页面定义
typedef struct page_clock
{
int num;
int visit;
}Page_clock;
//用于改进的CLOCK 算法的页面定义
typedef struct page
{
int num; //页面号
int fifo[M]; //FIFO
int c[M][N]; //存储每个阶段状态
//访问序列随机生成e 个,e 是工作集中包含的页数,m 是工作集移动率
void generate_list(int *list, int e, int m, int t)
{
int i, j = 0, q =P, r;
srand((unsigned)time(NULL));
while (j < e)
{
for (i = j;i < j + m;i++)
{
if (i == e)
break;
list[i] = (q + rand() % e) % N; /*保证在虚拟内存的页号内*/
b[i].modify = 0;
}
for(i = 0;i < M;i++)
{
for(j = 0;j < N;j++)
{
c[i][j] = -1;
}
}
}
//Clock 算法
void Clock(int fold,Page_clock *b_clock)
{
m=b[i];
b[i]=b[j];
b[j]=m;
}
}
}
if(l==1)
{
for(i=0;i<9;i++)
printf("199->");//已经到达最里面的磁道
for(j=n-1;j>0;j--)//磁头方向改为从里向外运动
{
printf("%d->",b[j]);
}
printf("%d\n",b[0]);
sum=2*199-b[n]-b[0];
printf("The sum is %d\n",sum);
}
#pragma warning (disable:4786)
#include<iostream>
#include<stdio.h>
#include <time.h>
#include <stdlib.h>
#include <map>
#include <vector>
#include <algorithm>
{
printf(" %2d ",a[j]); //读入内存顺序
}
printf(" \n");
printf("置换过程:");
print_format(e);
for(i = 0;i < M;i++)
{
for(j = 0;j < e;j++)