操作系统实验全(包含源代码)

操作系统实验报告书院系名称：电子工程学院电子指导教师：班级：学号：学生姓名：实验题目一：进程一、实验目的通过观察、分析实验现象，深入理解进程及进程在调度执行和内存空间等方面的特点，掌握在POSIX 规范中fork和kill系统调用的功能和使用。

二、实验内容（1）补充POSIX 下进程控制的残缺版实验程序（2）回答下列问题：1. 你最初认为运行结果会怎么样？2. 实际的结果什么样？有什么特点？试对产生该现象的原因进行分析。

3. proc_number 这个全局变量在各个子进程里的值相同吗？为什么？4. kill 命令在程序中使用了几次？每次的作用是什么？执行后的现象是什么？5. 使用kill 命令可以在进程的外部杀死进程。

进程怎样能主动退出？这两种退出方式哪种更好一些？三、实验步骤1.根据题意进入DOC环境中编写程序。

2.编译，链接，运行程序，进行调试。

3.分析实验结果及回答问题。

四、调试情况，回答问题及体会1、对自己设计进行评价，指出合理和不足之处，提出改进的方案。

2、在设计过程中的感受。

调试情况：回答上述实验内容中的问题1．预期结果：会持续输出0-9号进程，直到输入数字键+回车，则会杀死该进程，接下来的输出将不会有该进程号，当输入q+回车，则退出程序。

2．实际结果：与预期差不多，因输入进程总数20大于设定的最大进程数，因此按进程数10来处理。

随机输出0-9号进程，sleep(SLEEP_INTERV AL)，循环输出，直到输入数字键，则会杀死该数字对应的进程，直到输入q退出循环，然后杀死本组所有进程。

分析：每创建一个子进程时，将其pid存储在pid[i]中，i存储在proc_number，然后调用死循环函数do_something()，输出该进程的代号proc_number；当输入数字键时，主进程会执行kill(pid[ch-'0'],SIGTERM)，从而杀死（ch-‘0’）号进程。

《操作系统课程设计》实验报告学号：姓名：苏州大学计算机科学与技术学院2014年9月操作系统课程设计实验报告目录目录 (1)一、实验环境 (2)二、实验报告总体要求 (2)实验一编译L INUX内核 (3)实验二观察L INUX行为 (7)实验三进程间通信 (14)操作系统课程设计实验报告一、实验环境Linux平台◆硬件平台：普通PC机硬件环境。

◆操作系统：Linux环境，例如，红旗Linux或Red Hat Linux；启动管理器使用GRUB。

◆编译环境：伴随着操作系统的默认gcc环境。

◆工作源码环境：一个调试的内核源码，版本不低于2.4.20。

二、实验报告总体要求在2013年11月25日前提交实验报告。

实验报告至少要求包含以下内容：1.引言：概述本次实验所讨论的问题，工作步骤，结果，以及发现的意义。

2.问题提出：叙述本篇报告要解决什么问题。

注意不可以抄写实验要求中的表述，要用自己的话重新组织我们这里所提出的问题。

3.解决方案：叙述如何解决自己上面提出的问题，可以用小标题 3.1,3.2…等分开。

这是实验报告的关键部分，请尽量展开来写。

注意，这部分是最终课程设计的基本分的部分。

这部分不完成，本课程设计不会及格。

4.实验结果：按照自己的解决方案，有哪些结果。

结果有异常吗？能解释一下这些结果吗？同别人的结果比较过吗？注意，这部分是实验报告出彩的地方。

本课程设计要得高分，应该在这部分下功夫。

5.结束语：小结并叙述本次课程设计的经验、教训、体会、难点、收获、为解决的问题、新的疑惑等。

6.附录：加了注释的程序清单，注释行数目至少同源程序行数目比1：2，即10行源程序，至少要给出5行注释。

操作系统课程设计实验报告实验一编译Linux内核实验时间6小时实验目的认识Linux内核的组成，掌握配置、编译、安装Linux内核的步骤。

实验目标下载2.6.19或更新的Linux内核，配置该内核使其支持NTFS，并在新的内核中修改其版本为Linux NameTestKernel x.x.x，其中，Name是你的名字（汉语拼音）；x.x.x是新内核的版本号，最后在你的机器上编译安装这个新内核。

实验一进程管理1．目的和要求通过实验理解进程的概念，进程的组成（PCB结构），进程的并发执行和操作系统进行进程管理的相关原语（主要是进程的创建、执行、撤消）。

2．实验内容用C语言编程模拟进程管理，至少要有：创建新的进程；查看运行进程；换出某个进程；杀死运行进程以及进程之间通信等功能。

3．实验环境Windows操作系统、VC++6.0C语言4．实验提示PCB结构通常包括以下信息：进程名，进程优先数，轮转时间片，进程所占用的CPU时间，进程的状态，当前队列指针等。

可根据实验的不同，PCB结构的内容可以作适当的增删。

主体程序#include "conio.h"#include "stdio.h"#include "stdlib.h"struct jincheng_type{int pid;int youxian;int daxiao;int msg;int live;};struct jincheng_type neicun[20],waicun[20];int shumu=0,pid_l;main(){int n,m,i;char a;n=1;while(n==1){system("cls");printf("\n********************************************");printf("\n* 进程演示系统*");printf("\n********************************************");printf("\n 1.创建新的进程 2.查看运行进程");printf("\n 3.换出某个进程 4.杀死运行进程");printf("\n 5.进程之间通信 6.退出");printf("\n********************************************");printf("\n请选择（1～6) ");a=getch();switch(a){case'1':create( );break;case'2':viewrun( );break;case'3':huanchu();break;case'4':kill( );break;case'5':tongxun( );break;case'6': exit(0);default: n=0;}}}create( ) /* 创建一个进程的示例（不完整的程序）*/ {if(shumu>=20){printf("\n内存已满，请先结束或换出进程\n");}else{printf("\n请输入新进程的pid\n");scanf("%d",&neicun[shumu+1].pid);printf("\n请输入新进程的优先级\n");scanf("%d",&neicun[shumu+1].youxian);printf("\n请输入新进程的大小\n");scanf("%d",&neicun[shumu+1].daxiao);printf("\n请输入新进程的消息\n");scanf("%d",&neicun[shumu+1].msg);neicun[shumu+1].live=1;shumu++;}return neicun[shumu-1].live;}viewrun( )/*查看运行进程*/{int vpid;printf("\n请输入进程的pid\n");scanf("%d",&vpid);if(vpid>0&&vpid<=20&&neicun[vpid].live==1){printf("\n进程的pid是: %d\n",neicun[vpid].pid);printf("进程的优先级是: %d\n",neicun[vpid].youxian);printf("进程的大小是:%d\n",neicun[vpid].daxiao);printf("进程的消息是:%d\n",neicun[vpid].msg);}else{printf("\n所查看运行进程不存在\n");}printf("请按回车退出查看\n");vpid=getch();}huanchu()/*换出某个进程*/{int pid1,pid2;char c;printf("\n请输入第一个替换进程的pid\n");scanf("%d",&pid1);printf("\n请输入第二个替换进程的pid\n");scanf("%d",&pid2);if(pid1>0&&pid1<=20&&neicun[pid1].live==1){if(neicun[pid1].youxian>neicun[pid2].youxian){waicun[20].pid=neicun[pid1].pid;waicun[20].youxian=neicun[pid1].youxian;waicun[20].daxiao=neicun[pid1].daxiao;waicun[20].msg=neicun[pid1].msg;neicun[pid1].pid=neicun[pid2].pid;neicun[pid1].youxian=neicun[pid2].youxian;neicun[pid1].daxiao=neicun[pid2].daxiao;neicun[pid1].msg=neicun[pid2].msg;neicun[pid2].pid=waicun[20].pid;neicun[pid2].youxian=waicun[20].youxian;neicun[pid2].daxiao=waicun[20].daxiao;neicun[pid2].msg=waicun[20].msg;printf("\n替换完成\n");printf("\n被替换进程的pid是: %d\n",waicun[20].pid); printf("被替换进程的优先级是: %d\n",waicun[20].youxian); printf("被替换进程的大小是:%d\n",waicun[20].daxiao); printf("被替换进程的消息是:%d\n",waicun[20].msg);}else{printf("\n进程优先级不够大");}}else{printf("所查看运行进程不存在");}printf("请按回车退出换出进程\n");c=getche();return;}kill()/*杀死运行进程*/{int kpid;printf("\n请输入进程的pid\n");scanf("%d",&kpid);if(kpid>0&&kpid<20&&neicun[kpid].live==1){neicun[kpid].live=0;}return;}tongxun( )/*进程之间通信*/{int tpid1,tpid2;int buffer;char d;printf("\n请输入通信源进程pid\n");scanf("%d",&tpid1);printf("\n请输入通信目的进程pid\n");scanf("%d",&tpid2);if(tpid1>0&&tpid1<20&&neicun[tpid1].live==1){buffer=neicun[tpid1].msg;neicun[tpid1].msg=neicun[tpid2].msg;neicun[tpid2].msg=buffer;printf("\n源进程的消息是: %d\n",neicun[tpid1].msg);printf("\n目的进程的消息是: %d\n",neicun[tpid2].msg);}else{printf("\n所查看运行进程不存在\n");}printf("\n请按回车退出进程通信\n");d=getch();return;}5．实验运行结果******************************************** * 进程演示系统* ********************************************1.创建新的进程2.查看运行进程3.换出某个进程4.杀死运行进程5.进程之间通信6.退出系统******************************************** 请选择（1～6）然后根据你选择的不同，出现不同的结果。

操作系统上机实验报告实验一进程的建立1.实验目的学会通过基本的Windows进程控制函数，由父进程创建子进程，并实现父子进程协同工作。

2.实验软硬件环境Dev-C++3.实验内容创建两个进程，让子进程读取一个文件，父进程等待子进程读取完文件后继续执行，实现进程协同工作。

进程协同工作就是协调好两个进程，使之安排好先后次序并以此执行，可以用等待函数来实现这一点。

当需要等待子进程运行结束时，可在父进程中调用等待函数。

4.实验程序及分析实验程序源代码如下：父进程：#include<stdio.h>#include<windows.h>int main(){STARTUPINFO si;PROCESS_INFORMA TION pi; //当Windows创建新进程时，将使用这两个结构体的有关成员。

所以在创建子进程之前应该对结构体进行声明和初始化。

ZeroMemory(&pi,sizeof(pi));ZeroMemory(&si,sizeof(si));si.cb=sizeof(STARTUPINFO);if(CreateProcess("lab1.2.exe",NULL,NULL,NULL,FALSE,CREATE_NEW_CONSOLE,NULL ,NULL,&si,&pi))//创建一个新进程，若是成功，就返回1，进而实现if选择{printf("子进程已创建～\n");int i,sum=0;for(i=1;i<=100;++i){sum+=i;printf("sum=%d\n",sum);} //进行1+2+3+….+100计算WaitForSingleObject(pi.hProcess,INFINITE); FILE *fp;fp=fopen("date.txt","r");char ch=fgetc(fp); //创建文件并打开while(ch!=EOF){putchar(ch);ch=fgetc(fp);}fclose(fp); //关闭文件}elseprintf("子进程创建失败～\n");return 0;}子进程：#include<stdio.h>#include<stdlib.h>int main(){printf("子进程运行～\n");FILE *fp;if(fp=fopen("date.txt","w")){printf("已经创建文件!\n");int i;for(i=48;i<58;i++) fputc(i,fp);fputc('\n',fp);fclose(fp);printf("已经写入数据:"); //向文本中写入数据fp=fopen("date.txt","r");char ch=fgetc(fp);while(ch!=EOF){putchar(ch);ch=fgetc(fp); //输出数据}fclose(fp);}else printf("创建文件失败!\n");system("pause");return 0;}5. 实验截图说明及分析6. 实验心得体会掌握了父进程创建子进程的方法，对操作系统多线程认识更深了。

操作系统课程设计－银行家算法(流程图+源代码+设计报告)一、实验目的：熟悉银行家算法，理解系统产生死锁的原因及避免死锁的方法,加深记意。

二、实验要求：用高级语言编写和调试一个描述银行家算法的程序。

三、实验内容：1、设计一个结构体，用于描述每个进程对资源的要求分配情况。

包括：进程名--name[5]，要求资源数目--command[m]（m类资源），还需要资源数目--need[m]，已分配资源数目--allo[m]。

2、编写三个算法，分别用以完成：①申请资源；②显示资源；③释放资源。

（动态完成）四、程序流程图五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ /*四、程序流程图：五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include "dos.h"#include "conio.h"#define MOVEIN 1#define GUIYUE 2#define ACC 3#define OK 1#define ERROR 0#define MAXSH 7#define MAXSHL 10#define MAXINPUT 50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号，全局变量*/int writeok;int right;char wel[30] = {"Welcome To Use An_Li System"};char ente[76]={" 警告：未经作者同意不得随意复制更改！"};char rights[40]={"Copyright (c) 2002"};struct date today;struct time now;typedef struct{int data[maxsize];int top;}stack;int emptystack(stack *S){if(S->top==48&&S->data[S->top]==35)return(1); /*35 is '#'*/ else return(0);}int push(stack *S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}}int gettop(stack *S){return S->data[S->top];}int pop(stack *S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack *S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络 ");music(1,60);}else break;}delay(500000);for(i=0; ; i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/ gotoxy(2+i,11);cprintf("%c",ente);music(1,60);}else break;}delay(40000);for(i=0;;i++){if(rights != '\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/logined(){ int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候.....");gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f) /* f为频率*/{ int i;for(i=0;i<30*loop;i++){sound(f*20);delay(200);}nosound();}int analys(int s,int a){int hh,pos;switch(a){case (int)'i':hh=0;break;case (int)'+':hh=1;break;case (int)'*':hh=2;break;case (int)'(':hh=3;break;case (int)')':hh=4;break;case (int)'#':hh=5;break;case (int)'E':hh=6;break;case (int)'T':hh=7;break;case (int)'F':hh=8;break;default:{printf(" \n analys()分析发现不该有的字符 %c !(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符 ");printf("谢谢");printf("网 ");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case 3:case 43:case 63:case 73:act=4;return MOVEIN;case 0:case 40:case 60:case 70:act=5;return MOVEIN;case 11:case 81: act=6;return MOVEIN;case 92:case 22:act=7;return MOVEIN;case 84:act=11;return MOVEIN;/*-------------------------------------------*/ case 91:case 94:case 95:act=1;return GUIYUE;case 21:case 24:case 25:act=2;return GUIYUE;case 101:case 102:case 104:case 105:act=3;return GUIYUE;case 31:case 32:case 34:case 35:act=4;return GUIYUE;case 111:case 112:case 114:case 115:act=5;return GUIYUE;case 51:case 52:case 54:case 55:act=6;return GUIYUE;/*+++++++++++++++++*/case 15:return ACC;/*******************************/case 6:return 1;case 7:case 47:return 2;case 8:case 48:case 68:return 3;case 46:return 8;case 67:return 9;case 78:return 10;default:{if(a=='#')printf("");else printf(" \n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n ...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符 ");writeerror('0'," 不是所期望的! ");printf("谢谢");printf("网 ");return ERROR;}}}int writefile(int a,char *st){FILE *fp;fp=fopen("an_slr.txt","a");if(fp==0){printf("\nwrite error!!");writeok=0;}else{if(a==-1){fprintf(fp," %s ",st); /*若a==－1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n 测试日期： %d-%d-%d",today.da_year,today.da_mon,today.da_day); fprintf(fp," 测试时间：%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec);}else if(a>=0) fprintf(fp,"\n step: %02d , %s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char *st) /*错误类型文件*/{FILE *fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0') fprintf(fpp," %s ",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp," %s \'%c\'(位置:%d) ",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack *st;char r[MAXSH][MAXSHL]; /*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';initstack(st);push(st,48); /* (int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------");writefile(-1,"\n 计本003 安完成于2003.01.12 14:04");writefile(-1,"\n谢谢");writefile(-1,"网 ");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果： ");writefile(-2," ");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /* if ss=4 int =52 */ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /* #0 */s=gettop(st); /* s=0 */push(st,(int)r[act][0]);/*将产生式左端 F 进栈 */ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa) */if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf(" step %02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;} /*接受成功*/else{flag=0;right=0;} /* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串 %s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串 %s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果：输入串为可接受串!"); }}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告－操作系统课程设计－银行家算法(流程图+源代码+设计报告)六、测试报告：（测试结果保存于系统生成的an.txt 文件中）以下为课本上的实例：：-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available) A:3, B:3, C:2测试日期： 2003-6-28 请求分配时间： 14:07:29经测试，可为该进程分配资源。

操作系统实验指导书及代码《操作系统》实验指导书目录实验环境 ................................................. 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( )结束*/。

操作系统实验报告学院：计算机与通信工程学院专业：计算机与科学技术班级：学号：姓名：指导教师：王成耀成绩：2015年 1 月4 日实验一线程的状态和转换（5分）1 实验目的和要求目的：熟悉线程的状态及其转换，理解线程状态转换与线程调度的关系。

要求：（1）跟踪调试EOS线程在各种状态间的转换过程，分析EOS中线程状态及其转换的相关源代码；（2）修改EOS的源代码，为线程增加挂起状态。

2 完成的实验内容2.1 EOS线程状态转换过程的跟踪与源代码分析（分析EOS中线程状态及其转换的核心源代码，说明EOS定义的线程状态以及状态转换的实现方法；给出在本部分实验过程中完成的主要工作，包括调试、跟踪与思考等）//使 Zero 状态或者运行状态的线程转入就绪状态VOIDPspReadyThread(PTHREAD Thread){ASSERT(NULL != Thread);ASSERT(Zero == Thread->State || Running == Thread->State);// 将线程插入其优先级对应的就绪队列的队尾，并设置就绪位图中对应的位。

// 最后将线程的状态修改为就绪状态。

ListInsertTail(&PspReadyListHeads[Thread->Priority], &Thread->StateListEntry);BIT_SET(PspReadyBitmap, Thread->Priority);Thread->State = Ready;}//取消线程的就绪状态，使线程转入 Zero 状态VOIDPspUnreadyThread(PTHREAD Thread){ASSERT(NULL != Thread && Ready == Thread->State);// 将线程从所在的就绪队列中取出，如果线程优先级对应的就绪队列变为空，// 则清除就绪位图中对应的位。

进程管理实验报告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）实验题目和要求:修改已经编写的程序, 将每个进程输出一个字符改为每个进程输出一句话, 再观察程序执行时屏幕上出现的现象, 并分析原因。

西安交通大学实验报告——操作系统原理课内实验姓名：班级：学号：实验一用户接口实验一、实验目的1、理解并掌握面向操作命令的接口Shell，学会简单的shell编码。

2、理解操作系统调用的运行机制，掌握创建系统调用的方法。

二、实验内容1、控制台命令接口实验理解面向操作命令的接口shell和进行简单的shell编程。

该实验是通过“几种操作系统的控制台命令”、“终端处理程序”、“命令解释程序”和“Linux 操作系统的bash”来让实验者理解面向操作命令的接口shell 和进行简单的shell 编程。

●查看bash 版本。

●编写bash 脚本，统计/my 目录下c 语言文件的个数2) 系统调用实验。

2、系统调用实验理解操作系统调用的运行机制。

该实验是通过实验者对“Linux 操作系统的系统调用机制”的进一步了解来理解操作系统调用的运行机制；同时通过“自己创建一个系统调用mycall（）”和“编程调用自己创建的系统调用”进一步掌握创建和调用系统调用的方法。

●编程调用一个系统调用fork（），观察结果。

●编程调用创建的系统调用foo（），观察结果。

●自己创建一个系统调用mycall（），实现功能：显示字符串到屏幕上。

●编程调用自己创建的系统调用。

三、实验准备为了使用户通过操作系统完成各项管理任务，操作系统必须为用户提供各种接口来实现人机交互。

经典的操作系统理论将操作系统的接口分为控制台命令和系统调用两种。

前者主要提供给计算机的操作人员对计算机进行各种控制；而后者则提供个程序员，使他们可以方便地使用计算机的各种资源。

四、实验步骤及结果1、控制台命令接口实验（1）查看b ash 版本操作：在s hell 提示符下输入：$echo $BASH_VERSION结果：版本是4.2.42（1）-release（2）建立bash 脚本，输出Hello word操作：在编辑器中输入以下内容#!/bin/bashecho Hello World!结果：操作：执行脚本使用指令：$./text结果：（3）编写bash 脚本：统计/my 目录下 c 语言文件的个数通过bash 脚本，可以有多种方式实现这个功能，而使用函数是其中个一个选择。

实验四操作系统-动态分区分配算法萨斯的发生的v设计程序模拟四种动态分区分配算法：首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法的工作过程。

假设内存中空闲分区个数为n,空闲分区大小分别为P l,…，P n,在动态分区分配过程中需要分配的进程个数为m （m<n）,它们需要的分区大小分别为S i,…，S m,分别利用四种动态分区分配算法将m个进程放入n个空闲分区，给出进程在空闲分区中的分配情况。

程序要求如下：1）利用首次适应算法、循环首次适应算法、最佳适应算法和最坏适应算法四种动态分区分配算法模拟分区分配过程。

2）模拟四种算法的分区分配过程，给出每种算法进程在空闲分区中的分配情况。

3）输入：空闲分区个数n,空闲分区大小P i,…,P n,进程个数m, 进程需要的分区大小S i,…，S m,算法选择1-首次适应算法，2-循环首次适应算法，3-最佳适应算法，4-最坏适应算法。

4）输出：最终内存空闲分区的分配情况。

代码实现：#include<iostream>#include<fstream>#include<iomanip>using namespace std;const int MaxNumber=100;int FreePartition[MaxNumber];// 空闲分区大小int FirstPartition[MaxNumber];//1-首次适应算法int CycleFirstPartition[MaxNumber];//2-循环首次适应算法int BestPartition[MaxNumber];//3-最佳适应算法int WorstPartition[MaxNumber];//4-最坏适应算法int ProcessNeed[MaxNumber];// 进程需要的分区大小int PartitionNum,ProcessNum;char ProcessName[MaxNumber];// 进程名char ProcessPartition[MaxNumber];// 进程分配的序列int Partition[MaxNumber];char str[MaxNumber][MaxNumber];void FirstFit(int n,int m);void NextFit(int n,int m);void BestFit(int n,int m);void WorstFit(int n,int m);void Print(int n, int m);void Print2(int n, int m);//======================================================== void FirstFit(int n, int m){cout<<"选择了首次适应算法！"<<endl;cout<<endl;int i,j,k=0;for(i=0; i<n; i++){FirstPartition[i] = FreePartition[i];}for(j=0; j<m; j++){for(i=0; i<n; i++){if(ProcessNeed[j]<=FirstPartition[i]){ProcessPartition[j]=i;//str[i][k] = ProcessName[j];FirstPartition[i] = FirstPartition[i]-ProcessNeed[j]; break;}}}Print(n,m);cout<<"空间序号:"<<" ";for(i=0; i<n; i++)(cout<<T<<setw(m-1)<<"空间”<<(i+1);}cout<<endl;cout<<"分区大小:"<<" ";for(i=0; i<n; i++)(cout<<T<<setw(m)<<setiosflags(ios::left)<<FreePartition[i];}cout<<endl;cout<<"剩余分区大小:";for(i=0; i<n; i++)(cout<<"|"<<setw(m)<<setiosflags(ios::left)<<FirstPartition[i];}cout<<endl;Print2(n,m);}void NextFit(int n, int m)(cout<<"选择了循环首次适应算法!"<<endl;cout<<endl;int i,j,flag=0;for(i=0; i<n; i++)(CycleFirstPartition[i] = FreePartition[i];}for(j=0; j<m; j++)(for(i=flag; i<n; i++)(if(ProcessNeed[j]<=CycleFirstPartition[i])(ProcessPartition[j]=i;CycleFirstPartition[i] = CycleFirstPartition[i]-ProcessNeed[j];flag = i+1;if(i==n-1)(flag=O;)break;)))Print(n,m);cout«"空间序号:for(i=0; i<n; i++){cout«"|"«setw(m-1)«"空间"«(i+1);)cout«endl;cout«"分区大小："vv"for(i=0; i<n; i++){cout«"|"«setw(m)«setiosflags(ios::left)«FreePartition[i];)cout«endl;cout«"剩余分区大小:";for(i=0; i<n; i++){cout«"|"«setw(m)«setiosflags(ios::left)«CycleFirstPartition[i];)cout«endl;Print2(n,m);)void BestFit(int n, int m){cout«"选择了最佳适应算法!"«endl;cout«endl;int i j,flag=O,temp,id=O,flag1 =0;for(i=0; i<n; i++){BestPartition[i] = FreePartition[i];)while(flag1<m){flag = 0;for(i=0; i<n; i++)Partition[i]=0;}for(i=0; i<n; i++)(if(ProcessNeed[flag1]<=BestPartition[i])(Partition[flag]=i;flag += 1;}}temp = BestPartition[Partition[0]];id = Partition]。

计算机操作系统实验指导汤小丹版源代码```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语言，实现了一个简单的操作系统进程调度算法模拟。

操作系统lab2实验报告操作系统 Lab2 实验报告一、实验目的本次实验着重学习操作系统内存管理的相关概念和技术，包括页表的建立和管理，以及虚拟内存系统的实现和优化。

通过完成本实验，我们能够加深对操作系统内存管理机制的理解，并掌握相关的实现方法。

二、实验环境本次实验使用的实验环境为 Linux 操作系统（具体版本号）、GCC 编译器（具体版本号）以及所提供的模拟器。

三、实验内容本次实验主要包括以下几个任务：1. 理解虚拟内存和物理内存的概念，掌握页表的结构和管理方法。

2. 编写代码实现一个简单的页表建立和管理的模拟器，包括页表的初始化、地址映射和页表的更新。

3. 实现一个简单的虚拟内存系统，包括页的加载、替换等操作。

4. 对实现的虚拟内存系统进行性能优化，包括缓存算法的改进、预加载等策略的应用。

四、实验步骤及结果1. 理解虚拟内存和物理内存的概念在本次实验中，我们将使用虚拟内存系统来管理进程的地址空间。

虚拟内存是操作系统提供给进程的一种抽象概念，它为每个进程提供了一个独立的、连续的地址空间。

物理内存是实际存在的计算机内存，由物理地址组成。

2. 编写页表管理模拟器代码根据实验要求，我们需要编写代码模拟页表的建立和管理过程。

首先，我们需要实现页表的初始化函数，用于初始化页表的数据结构。

接着，我们需要实现地址映射函数，用于将虚拟地址映射到物理地址。

最后，我们需要实现页表的更新函数，用于更新页表中的相关信息。

3. 实现虚拟内存系统在本次实验中，我们需要实现一个简单的虚拟内存系统。

虚拟内存系统可以将虚拟地址映射到物理地址，并且可以实现页的加载和替换操作。

我们需要实现页面加载函数，用于将页面加载到内存中。

同时，我们还需要实现页面替换函数，当内存空间不足时，根据特定的算法选择待替换的页，并将其移出内存。

4. 性能优化为了提高虚拟内存系统的性能，我们可以采用一些优化策略。

例如，我们可以改进缓存算法，通过提前缓存一些可能会被访问的页面，减少缺页次数。

操作系统实验指导适用课程：操作系统适用专业：计算机科学与技术软件工程目录实验环境的使用 (3)操作系统的启动 (11)进程的创建 (16)进程的同步 (22)时间片轮转调度 (29)分页存储器管理 (33)设备驱动程序 (40)FAT12文件系统 (46)实验环境的使用实验性质：验证建议学时：2学时一、实验目的●熟悉操作系统集成实验环境OS Lab的基本使用方法。

●练习编译、调试EOS操作系统内核以及EOS应用程序。

二、预备知识阅读《EOS实验指南》第一章，对EOS操作系统和集成实验环境有一个初步的了解。

三、实验内容3.1 启动OS Lab1.在安装有OS Lab的主机上，可以使用两种不同的方法来启动OS Lab：●在桌面上双击“Tevation OS Lab”图标。

●点击“开始”菜单，在“程序”中的“Tevation OS Lab”中选择“TevationOS Lab”。

2.OS Lab每次启动后都会首先弹出一个用于注册用户信息的对话框（可以选择对话框标题栏上的“帮助”按钮获得关于此对话框的帮助信息）。

在此对话框中填入学号和姓名后，点击“确定”按钮完成本次注册。

3.观察OS Lab主窗口的布局。

OS Lab主要由下面的若干元素组成：菜单栏、工具栏以及停靠在左侧和底部的各种工具窗口，余下的区域用来放置编辑器窗口。

3.2 学习OS Lab的基本使用方法通过练习使用OS Lab编写一个Windows控制台应用程序，熟悉OS Lab的基本使用方法（包括新建项目、生成项目、调试项目等）。

3.2.1 新建Windows控制台应用程序项目新建一个Windows控制台应用程序项目的步骤如下：1.在“文件”菜单中选择“新建”，然后单击“项目”。

2.在“新建项目”对话框中，选择项目模板“控制台应用程序(c)”。

3.在“名称”中输入新项目使用的文件夹名称“oslab”。

4.在“位置”中输入新项目保存在磁盘上的位置“C:\Test”。

（操作系统原理和linux操作系统相结合的实验）实验二进程的通信一实验目的1 学会使用vi编辑器编辑C语言程序2 学会Linux环境下gcc的使用3 学会调试工具GDB的使用二实验原理1 利用linux提供的进程通信的系统调用设计进程通信程序，加深对进程通信概念的理解。

2 体会进程通信的方法和效果。

三实验环境PC机1台，Windows操作系统和其上的虚拟Linux操作系统。

四实验步骤1．管道通信(1)编写一个程序。

父进程创建一个子进程和一个无名管道fd，由子进程向管道写入信息“This is a message”，然后终止执行；父进程接收到子进程终止信号后从管道中读出并显示信息后结束。

#include<stdio.h>#include<unistd.h>main(){int p1,fd[2];char outpipe[50]; //定义读缓冲区char inpipe[50]="This is a message!"; //定义写缓冲区pipe(fd); //创建无名管道fdwhile((p1=fork())==-1);if (p1==0) //子进程返回{write(fd[1],inpipe,50); //写信息到管道exit(0);}else //父进程返回{wait(0); //等待子进程终止read(fd[0],outpipe,50); //从管道读信息到读缓冲区printf("%s\n",outpipe); //显示读到的信息exit(0);}}(2)父进程创建两个子进程，父子进程之间利用管道进行通信。

要求能显示父进程、子进程各自的信息，体现通信效果。

(源程序pipe_1.c)#include<stdio.h>main(){int I,r,j,k,l,p1,p2,fd[2];char buf[50],s[50];pipe(fd);while((p1=fork())==-1);if(p1==0){lockf(fd[1],1,0);sprintf(buf,"Child process p1 is sending message!\n");printf("Child process p1!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p1 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{while((p2=fork())==-1);if(p2==0){lockf(fd[1],1,0);sprintf(buf,"Child process p2 is sending message!\n");printf("Child process p2!\n");write(fd[1],buf,50);lockf(fd[1],0,0);sleep(5);j=getpid();k=getppid();printf("p2 %d is weakup.My parent process id is %d.\n",j,k);exit(0);}else{I=getpid();wait(0);if(r=read(fd[0],s,50)==-1)printf("can’t read pip e.");elseprintf("Parent %d:%s\n",l,s);wait(0);if(r=read(fd[0],s,50)==-1)pr intf("can’t read pipe");elseprintf ( "Parent %d:%s\n",l,s);exit(0);}}}结果：2.共享内存通信。

成绩《操作系统》实验报告学院计算机学院专业软件工程学号姓名指导教师日期2014年7月实验一：进程调度实验题目11.实验要求：编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。

2、实验原理“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。

动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。

例如：在进程获得一次CPU后就将其优先数减少1。

或者，进程等待的时间超过某一时限时增加其优先数的值，等等3、流程图4、源代码#include "stdio.h"#include <stdlib.h>#include <conio.h>#define getpch(type) (type*)malloc(sizeof(type))//#define NULL 0struct pcb { /* 定义进程控制块PCB */char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void 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;}}void input() /* 建立进程控制块函数*/{int i,num;// clrscr(); /*清屏*/printf("\n 请输入进程号?");scanf("%d",&num);for(i=0;i<num;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);}void 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");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/disp(p);pr=ready;printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{printf("\n 进程 [%s] 已完成.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{(p->rtime)++;if(p->rtime==p->ntime)destroy(); /* 调用destroy函数*/else{(p->super)--;p->state='w';sort(); /*调用sort函数*/}}int 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();return 0;}5、运行结果6、体会心得题目21、实验要求:编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。