编写单通路IO系统中的设备分配程序实验报告

1、合肥学院计算机科学与技术系实验报告2009 2010学年第1 学期课程 操作系统原理实验名称编写单通路i/o系统中的 设备分配程序学生姓名 冯阿雷 毕秋平 高健 宁阳专业班级 07计本（1）班指导教师屠 菁2000 年 12 月一、实验目的熟练掌握单通路i/o系统中的设备分配方法。二、实验内容本实验要求实现模拟单通路i/o系统中的设备分配程序，有如下要求：1、设计系统设备表sdt、设备控制表dct、控制器表coct、通道表chct和逻辑设备表lut。2、提供给用户各表目的初态。3、回答信息： 能够分配时，给出设备号、控制器号、通道号， 否则，给出无法分配的回答，插入相应的等待队列。三、实验步骤

2、1、 任务分析为单通路i/o系统设计系统设备表sdt、设备控制表dct、控制器表coct、通道表chct和逻辑设备表lut五张表。用户可以查看各表目的内容，另外，程序为用户进程分配设备，并且输出分配结果，如果能够分配，则给出设备号、控制器号、通道号，否则，给出无法分配的回答，插入相应的等待队列。2、概要设计为实现本次实验任务要求，首先，定义sdt、dct、coct、chct、lut五张表，调用input（）函数初始化各表内容；其次，调用print（）函数，实现对上述四张表的输出显示；最后，调用add_process（）函数，为用户进程申请设备，如果分配成功，给出设备号、控制器号、通道号，否则，

3、给出无法分配的原因，并将该进程插入相应的等待队列中。本程序包含如下3个模块：（1） 主模块，由函数main（）组成。（2） 显示表目模块，由函数print（）组成。（3） 分配设备模块，由函数add_process（）、process_run（）等函数组成。绘制流程图如下：运行程序主函数运行进程申请设备显示sdt、coct、dct、chct、lut五张表退出判断设备是否存在输出无法分配原因判断控制器是否忙输出无法分配原因输入所需设备名称（输入0退出申请）判断通道是否忙输出无法分配原因给予分配，输出分配信息ynynyn输入0输入非0 流程图3、详细设计和编码通过以上的分析和初步设计，已经对本程序

4、作了初步了解。下面将对本程序的各个模块作详细的讲解。（1）主函数模块对各个表就行初始化，设置好各个表的状态，以及对各个步骤进行函数调用来实现本实验的要求。（2）显示表目模块调用print（）函数，显示出sdt系统设备表、dct设备控制表、coct控制器控制表、chct通道表和lut逻辑设备表五张表目，直接显示各表中的设备类型、设备名称和设备状态等信息。(3) 分配设备模块在此模块中，首先调用add_process（）函数，要求用户输入所要申请的逻辑设备名称，然后根据逻辑设备名称查看lut表中的该设备是否存在，若不存在，则直接退出分配，输出分配失败原因，若存在，则继续如下分析：a.分配设备。根据

5、lut表找到设备表，然后根据sdt表中指向dct表该设备的指针，检索到dct设备控制表中该物理设备，检查该设备的状态信息busy。若忙，则将要求i/o的进程插入到该设备的等待队列中等待；若不忙，则继续步骤（b）。b.分配控制器。根据设备控制表dct中的控制器表指针，可找到与此设备相连的控制器表coct，通过检查该表中的状态信息busy。若忙，则将要求i/o的进程插入到等待该控制器的队列中等待；若不忙，则把该控制器分配给进程，继续步骤（c）。c.分配通道。首先根据控制器表coct中的通道表指针找到与此控制器相连的通道表chct，从中了解此通道的状态信息busy。若为忙，则把该进程插入等待通道的队

6、列chl中;若通道空闲，则表明本次i/o请求所需之i/o设备和相应的控制器、通道都能得到，于是便可启动i/o设备开始数据传送。调用add_process（）函数来实现上述步骤。分配完成后，将相应的设备、控制器和通道的状态信息busy置1。结束分配程序。4、调试分析本次程序设计的核心内容在于设备的分配过程，一次分配只有在设备、控制器和通道三者都分配成功时，这次分配才算成功。该程序的核心逻辑关系是先分配设备再分配控制器最后分配通道。当三者都空闲并安全时，才可分配，最终启动该i/o设备进行数据传送。5、测试结果运行程序后，运行结果如下图1。图1进行初始化，运行结果如下图2图2图3各表的初始化状态如图

7、3。 图3进程分配设备结果如图3四、实验总结通过本次实验，充分的理解了单通道i/o设备分配程序，知道了设备表，控制器表，通道表以及其他表的数据结构，加深了对课本知识的理解，明白了设备分配的过程：先分配设备，接下来分配控制器，然后再分配通道，若成功就可以启动该i/o设备进行数据传送了。同时，通过和同学一起做这个实验，从中学习到了合作的经验，为以后的工作打下基础。经过编写程序，复习了c语言程序。五、附录源程序：#include#include#include#include#define name_num 10typedef struct _coct_listchar namename_num;s

8、truct _coct_list *next; coct_list;typedef struct _chctchar namename_num;/int state;/coct_list *coct_head;coct_list *coct_tail;struct _chct *next; chct;typedef struct _dct_listchar namename_num;/等待控制器队列的设备名字struct _dct_list *next; dct_list;typedef struct _coctchar namename_num;/int state;/chct *chct;

9、/dct_list *dct_head;/等待控制器队列的队首指针dct_list *dct_tail;/struct _coct *next; coct;/设备控制表typedef struct _processchar * namename_num;/进程名字/int num;/进程标志号struct _process *next; process;typedef struct _dctchar namename_num;/设备名字char typename_num;/设备类型int adr;/设备地址int state;/设备状态coct *coct;/指向控制器表的指针process

10、*process_head;/等待进程的队首指针process *process_tail;/等待进程的队尾指针int repeat;/重复次数struct _dct *next; dct;/系统设备表sdttypedef struct _sdtchar namename_num;char typename_num;/设备类型dct *dct;/dct指针long adr;/驱动程序入口 sdt;typedef struct _lutchar namename_num;char dct_namename_num;int adr;struct _lut *next; lut;/默认状态下初始化书

11、中p113的单通道i/odct *main_dct;coct *main_coct;chct *main_chct;lut *main_lut;void init_1();void init()puts(-);puts( 进行初始化工作 ,请您输入相关内容);/puts(n 如:与设备1有关的控制器名为控制器1,通道名为通道1,您应如下输入:);puts(n 如:与设备1有关的控制器名为控制器1,通道名为通道1,您应如下输入:);puts(n 请输入设备号: (此处输入:设备1);puts( 请输入控制器号: (此处输入:控制器1);puts( 请输入通道号: (此处输入:通道1);puts(

12、 这样完成一次输入);puts(n 注意:当设备号为-1时,退出输入);puts(-);init_1();void init_1()dct *dct;coct *coct;chct *chct;lut *lut;dct=(dct *)malloc(sizeof(dct);main_dct=dct;dct-next=null;coct=(coct *)malloc(sizeof(coct);main_coct=coct;coct-next=null;chct=(chct *)malloc(sizeof(chct);main_chct=chct;chct-next=null;lut=(lut *)

13、malloc(sizeof(lut);main_lut=lut;lut-next=null;void input()dct *dct;dct *dct_1;dct *dct_2;coct *coct;coct *coct_1;chct *chct;chct *chct_1;lut *lut;lut *lut_1;char namename_num;int a;while(1)a=0;puts(n+n);printf(请输入设备号:);scanf(%s,name);if(!strcmp(name,-1)break;dct_2=main_dct;dct_1=main_dct-next;while(

14、dct_1!=null)if(!strcmp(dct_1-name,name)printf(n该设备已存在,请重新输入:);scanf(%s,name);dct_1=main_dct-next;dct_2=main_dct;continue;/if(dct_1-next!=null)dct_1=dct_1-next;dct_2=dct_2-next;/if(dct_1-next=null)/break;if(dct_1=null)dct_1=dct_2;dct=(dct *)malloc(sizeof(dct);if(dct_1=null)dct_1=main_dct;dct_1-next=d

15、ct;dct-next=null;strcpy(dct-name,name);dct-adr=(int)&dct;dct-process_head=null;dct-process_tail=null;dct-repeat=5;dct-state=0;strcpy(dct-type,输入设备);printf(n请输入控制器号:);scanf(%s,name);coct_1=main_coct-next;while(coct_1!=null)if(!strcmp(coct_1-name,name)dct-coct=coct_1;coct=coct_1;a=1;break;/if(coct_1-n

16、ext!=null)coct_1=coct_1-next;/if(coct_1-next=null)/break;if(coct_1=null)coct=(coct *)malloc(sizeof(coct);dct-coct=coct;strcpy(coct-name,name);coct-dct_head=null;coct-dct_tail=null;coct-next=null;coct-state=0;coct_1=main_coct;while(coct_1-next!=null)coct_1=coct_1-next;coct_1-next=coct;if(a=1)puts( 控制

17、器存在，不能指定通道。输入任意键进行下一设备的设置！);getch();continue;printf(n请输入通道号:);scanf(%s,name);chct_1=main_chct-next;while(chct_1!=null)if(strcmp(chct_1-name,name)coct-chct=chct_1;chct=chct_1;break;/if(chct_1-next!=null)chct_1=chct_1-next;/if(chct_1-next=null)/break;if(chct_1=null)chct=(chct*)malloc(sizeof(chct);coct

18、-chct=chct;strcpy(chct-name,name);chct-coct_tail=null;chct-next=null;chct-coct_head=null;chct-state=0;chct_1=main_chct;while(chct_1-next!=null)chct_1=chct_1-next;chct_1-next=chct;puts( 为各设备确定逻辑设备名!n);dct=main_dct-next;while(dct!=null)printf( 请输入设备号为%s的逻辑设备名:,dct-name);scanf(%s,name);lut=main_lut-nex

19、t;lut_1=main_lut;while(lut!=null)if(!strcmp(lut-name,name)printf( n 该设备名已近存在，请重新输入！n);printf( 请输入设备号为%s的逻辑设备名:,dct-name);scanf(%s,name);lut=main_lut-next;lut_1=main_lut;break;lut=lut-next;lut_1=lut_1-next;lut=lut_1;lut_1=(lut *)malloc(sizeof(lut);lut-next=lut_1;strcpy(lut_1-name,name);strcpy(lut_1-d

20、ct_name,dct-name);lut_1-next=null;dct=dct-next;void print()dct *dct;chct *chct;coct *coct;process *process;dct_list *dct_list;coct_list *coct_list;lut *lut;dct=main_dct-next;puts(nnnnnnnnnnnnnnnnnnnnnnnnn);puts(-);puts(n dct表n);puts(-);puts(|_设备标志符_| |_设备类型 _| |_设备地址_| |_控制表指针_| |_重复次数 _| |_ 状态 _|);

21、while(dct!=null)printf(n|%10s |%10s |%10d |%10s |%10d |%10d |,dct-name,dct-type,dct-adr,dct-coct-name,dct-repeat,dct-state);if(dct-process_tail=null)printf(nn 设备%s 等待队列为空n,dct-name);if(dct-process_tail!=null)printf(nn 设备%s的进程等待队列的进程号为:n,dct-name);process=dct-process_head;while(process!=null)/printf(

22、 |_ %10s _|_ %10d _| ,process-name,process-num);printf( |_ %10s _| ,process-name);process=process-next;dct=dct-next;puts(n);puts(-);puts(n coct表n);puts(-);puts(|_ 控制器名称 _| |_ 控制器状态 _| |_ 对应通道名称 _|);coct=main_coct-next;while(coct!=null)printf(n|%10s |%10d |%10s |,coct-name,coct-state,coct-chct-name);

23、if(coct-dct_tail=null)printf(nn 控制器%s等待队列为空！n,coct-name);if(coct-dct_tail!=null)dct_list=coct-dct_head;printf(nn 控制器%s的等待队列的设备号是:n,coct-name);while(dct_list!=null)printf( |_ %10s _| ,dct_list-name);dct_list=dct_list-next;coct=coct-next;puts(n);puts(-);puts(n chct表n);puts(-);puts(|_ 通道名称 _| |_ 通道状态 _

24、| );chct=main_chct-next;while(chct!=null)printf(n| %10s | %10d |n,chct-name,chct-state);if(chct-coct_tail=null)printf(nn 通道%s的等待队列为空！,chct-name);if(chct-coct_tail!=null)coct_list=chct-coct_head;printf(nn 通道%s的等待队列是:n,chct-name);while(coct_list!=null)printf( |_ %10s _|,coct_list-name);coct_list=coct_

25、list-next;chct=chct-next;puts(n);puts(-);puts(n lut表n);puts(-);lut=main_lut-next;printf( |_ 逻辑设备名_| |_ 物理设备名_|);while(lut!=null)printf(n |_ %10s _| | %10s _|,lut-name,lut-dct_name);lut=lut-next;void free_main()dct *dct;dct *dct1;coct *coct;coct *coct1;chct *chct;chct *chct1;lut *lut;lut *lut1;dct_li

26、st *dct_list1;dct_list *dct_list2;coct_list *coct_list1;coct_list *coct_list2;process *process1;process *process2;dct=main_dct-next;while(dct!=null)dct1=dct-next;process1=dct-process_head;while(process1!=null)process2=process1-next;free(process1);process1=process2;free(dct);dct=dct1;coct=main_coct-n

27、ext;while(coct!=null)coct1=coct-next;dct_list1=coct-dct_head;while(dct_list1!=null)dct_list2=dct_list1-next;free(dct_list1);dct_list1=dct_list2;free(coct);coct=coct1;chct=main_chct-next;while(chct!=null)chct1=chct-next;coct_list1=chct-coct_head;while(coct_list1!=null)coct_list2=coct_list1-next;free(

28、coct_list1);coct_list1=coct_list2;free(chct);chct=chct1;lut=main_lut-next;while(lut!=null)lut1=lut-next;free(lut);lut=lut1;free(main_dct);free(main_coct);free(main_chct);free(main_lut);void add_dct_list(coct *coct1,char *dct_name);void add_coct_list(chct *chct1,char *coct_name);void add_process()cha

29、r process_namename_num;char lut_namename_num;char dct_namename_num;lut *lut;dct *dct;coct *coct;chct *chct;process *process;puts(nnnnnnnnnnnnnnnnnnnnnnnnnn);puts();puts();puts( 输入进程信息 );puts(nnn);puts( 如果进程名为-1，将切换到进程运行状态！);while(1)printf(nnn 请输入进程名:);scanf(%s,process_name);if(!strcmp(process_name,-

30、1)break;printf( 请输入逻辑设备名:);scanf(%s,lut_name);puts(_);lut=main_lut-next;while(lut!=null)if(!strcmp(lut-name,lut_name)strcpy(dct_name,lut-dct_name);break;lut=lut-next;if(lut=null)printf(n 没有找到该设备，请确认该设备正确安装!n);if(lut!=null)dct=main_dct-next;while(dct!=null)if(!strcmp(dct-name,dct_name)if(dct-process_

31、head!=null)process=(process *)malloc(sizeof(process);dct-process_tail-next=process;dct-process_tail=process;if(dct-state=1)printf(n 设备正占用着，进程进入等待队列!,dct-name);add_dct_list(dct-coct,dct-name);if(dct-state=0)printf(n 设备%s空闲，能使用!-设备成功分配,dct-name);add_dct_list(dct-coct,dct-name);dct-state=1;process-next

32、=null;strcpy(process-name,process_name);if(dct-process_head=null)process=(process *)malloc(sizeof(process);dct-process_head=process;dct-process_tail=process;if(dct-state=1)printf(n %s设备正占用着，进程进入等待队列!,dct-name);add_dct_list(dct-coct,dct-name);if(dct-state=0)printf(n 设备%s空闲，能使用!-设备成功分配,dct-name);add_d

33、ct_list(dct-coct,dct-name);dct-state=1;process-next=null;strcpy(process-name,process_name);dct=dct-next;void add_dct_list(coct *coct1,char *dct_name)coct *coct;dct_list *dct_list;coct=coct1;if(coct-state=1)printf(n 控制器%s被占用着不能分配!将进入等待队列中!,coct-name);dct_list=(dct_list *)malloc(sizeof(dct_list);coct-

34、dct_tail-next=dct_list;coct-dct_tail=dct_list;dct_list-next=null;strcpy(dct_list-name,dct_name);add_coct_list(coct-chct,coct-name);if(coct-state=0)printf(n 控制器%s空闲，能分配使用!-控制器成功分配,coct-name);coct-state=1;dct_list=(dct_list *)malloc(sizeof(dct_list);coct-dct_head=dct_list;coct-dct_tail=dct_list;dct_li

35、st-next=null;strcpy(dct_list-name,dct_name);add_coct_list(coct-chct,coct-name);void add_coct_list(chct *chct1,char *coct_name)chct *chct;coct_list *coct_list;chct=chct1;if(chct-state=1)printf(n 通道%s正在使用，控制器进入等待对列中!,chct-name);coct_list=(coct_list *)malloc(sizeof(coct_list);chct-coct_tail-next=coct_l

36、ist;chct-coct_tail=coct_list;coct_list-next=null;strcpy(coct_list-name,coct_name);if(chct-state=0)printf(n 通道%s成功分配，开始运行该程序!- 通道成功分配,chct-name);chct-state=1;coct_list=(coct_list *)malloc(sizeof(coct_list);chct-coct_head=coct_list;chct-coct_tail=coct_list;coct_list-next=null;strcpy(coct_list-name,coc

37、t_name);void process_run_coct(char *coct_name);void process_run(char *chct_name)chct *chct;coct_list *coct_list;coct *coct;dct_list *dct_list;dct *dct;chct=main_chct-next;while(chct!=null)if(!strcmp(chct-name,chct_name)break;chct=chct-next;if(chct=null)printf(nn 没有通道!,chct-name);return ;if(chct-coct

38、_head=null)printf(n 通道%s处于空闲状态,chct-name);return;if(chct-coct_head=chct-coct_tail)coct_list=chct-coct_head;coct_list-next=null;chct-coct_head=null;chct-coct_tail=null;chct-state=0;if(chct-coct_head!=chct-coct_tail)coct_list=chct-coct_head;chct-coct_head=coct_list-next;coct_list-next=null;process_run_coct(coct_list-name);free(coct_list);void process_run_process(char *dct_name);void process_run_coct(char *coct_name)coct *coct;dct_list *dct_list;coct=main_coct-next;while(coct!=null)if(!strcmp(coct-name,coct_name)break;coct=coct-next;if(