操作系统实验三
操作系统实验,实验3, 进程管理 (1)
在图形界面上利用终端通过命令“su - ”切换到超级用户，编辑文件 “job”； 按组合键[Ctrl+Alt+F2]切换到第二个虚拟终端（超级用户）； 输入命令“at –f job now+1 minute”，设置1分钟后执行at调度内容； 稍等后观察at调度的执行效果，再切换到第一个虚拟终端观察at调度 的执行效果；
切换到第一个虚拟终端观察at调度的执行效果（5分钟后系统将执行重 启调度任务）。
[操作要求2] 设置一个调度，要求1分钟后执行文件job中的作业。 文件job的内容为： find /home/jkx/ -name “*.c” > /home/jkx/fdresult wall user jkx, all code files have been searched out! Please check out. [操作步骤]
续表
守 护 进 程 innd Usenet新闻服务器 功 能 说 明
linuxconf
lpd named netfs network
允许使用本地WEB服务器作为用户接口来配置机器
打印服务器 DNS服务器 安装NFS、Samba和NetWare网络文件系统 激活已配置网络接口的脚本程序
nfsd
portmap postgresql routed sendmail
事件（例如xinetd和lpd）
启动守护进程有如下几种方法
在引导系统时启动 人工手动从shell提示符启动
系统启动script的执行期间 被启动（/etc/rc.d） 任何具有相应执行 权限的用户
使用crond守护进程启动
执行at命令启动
守护进程一般由系统在开机时通过脚本或root
操作系统实验3-进程控制
WORD wMajorReq=(WORD)(dwVerReq>16);
WORD wMinorReq=(WORD)(dwVerReq&0xffff);
::cout<<"Process ID:"<<dwIdThis<<",requires OS:"<<wMajorReq<<wMinorReq<<::endl;
{
//改变优先级
::SetPriorityClass(
::GetCurrentProcess(), //利用这一进程
HIGH_PRIORITY_CLASS); //改变为high
//报告给用户
::cout<<"Task Manager should indicate this "
"process is high priority."<<::endl;
//设置版本信息的数据结构，以便保存操作系统的版本信息
OSVERSIONINFOEX osvix;
::ZeroMemory(&osvix,sizeof(osvix));
osvix.dwOSVersionInfoSize=sizeof(osvix);
//提取版本信息和报告
::GetVersionEx(reinterpret_cast<LPOSVERSIONINFO>(&osvix));
Parent();
}
return 0;
}
分析：程序4-3.cpp说明了一个进程从“生”到“死”的整个一生，第一次执行时，它创建一个子进程，其行为如同“父亲”。在创建子进程之前，先创建一个互斥的内核对象，其行为对于子进程来说，如同一个“自杀弹”。当创建子进程时，就打开了互斥体并在其他线程中进行别的处理工作，同时等待着父进程使用ReleaseMutex（）API发出“死亡”信号。然后用Sleep（）API调用来模拟父进程处理其他工作，等完成时，指令子进程终止。
操作系统 实验三 进程同步
集美大学计算机工程学院实验报告课程名称：操作系统指导教师：王丰实验成绩：实验编号：实验三实验名称：进程同步班级：计算12姓名：学号：上机实践日期：2015.5上机实践时间：2学时一、实验目的1、掌握用Linux信号灯集机制实现两个进程间的同步问题。
2、共享函数库的创建二、实验环境Ubuntu-VMware、Linux三、实验内容⏹需要的信号灯: System V信号灯实现☐用于控制司机是否可以启动车辆的的信号灯 S1=0☐用于控制售票员是否可以开门的信号灯 S2=0System V信号灯实现说明□ System V的信号灯机制属于信号灯集的形式, 一次可以申请多个信号灯.□同样利用ftok()生成一个key： semkey=ftok(path,45);□利用key申请一个包含有两个信号灯的信号灯集, 获得该集的idsemid=semget(semkey,2,IPC_CREAT | 0666);□定义一个联合的数据类型union semun{int val;struct semid_ds *buf;ushort *array;};□利用semctl()函数对信号灯初始化,参数有:信号灯集的id: semid要初始化的信号灯的编号:sn要设定的初始值:valvoid seminit(int semid, int val,int sn){union semun arg;arg.val=val;semctl(semid,sn,SETVAL,arg);}利用初始化函数,初始化信号灯:seminit(semid,0,0);//用来司机启动汽车的同步seminit(semid,0,1);//用来售票员开门的同步控制□利用semop()函数, 对信号灯实现V操作:sembuf是一个在头部文件中的预定义结构、semid—信号灯集id, sn—要操作的信号灯编号void semdown(int semid,int sn){/* define P operating*/struct sembuf op;op.sem_num=sn;op.sem_op=-1;//P操作为-1op.sem_flg=0;semop(semid,&op,1);}2、Linux的静态和共享函数库·Linux生成目标代码： gcc -c 源程序文件名（将生成一个与源程序同名的.o目标代码文件。
哈工大《操作系统》实验3
向kernel/printk.c中添加日志打印功能，将以下代码添加到原文件中：
在kernel/fork.c、kernel/sched.c和kernel/exit.c中，找到正确的状态转换点，并添加合适的状态信息，把它输出到log文件之中。
fork.c的修改如下：
exit.c的修改如下：
sched.c的修改如下：
在虚拟机上运行ls -l /var”或“ll /var”查看process.log是否建立，及它的属性和长度；
修改时间片
include/linux/sched.h宏INIT_TASK中定义的：
0,15,15, 分别对应state、counter和priority，将priority值修改，即可实现对时间片大小的调整。
0,15,15, 分别对应state、counter和priority，
priority值修改，即可实现对时间片大小的调整。
在修改时间片将priority由15改为150后，Process 9~20 中Turnaround, Waiting, CPU Burst, I/O Burst变化不大，原因可能是程序中I/O操作占用的时间对于总时间影响的权重过大，导致处理时间体现的并不明显。
或者变化不大的原因是，子进程连续占用cpu的时间要比时间片大很多。
操作系统实验三 时间片轮转法完成进程调度
实验三：时间片轮转法完成进程调度一、实验目的：（1）加深对进程的理解（2）理解进程控制块的结构（3）理解进程运行的并发性（4）掌握时间片轮转法进程调度算法实验内容：（1）建立进程控制块（2）设计三个链队列，分别表示运行队列、就绪队列和完成队列（3）用户输入进程标识符以及进程所需的时间，申请空间存放进程PCB信息。
（4）每一个时间片结束输出各进程的进程号，CPU时间（即已经占用的CPU时间），所需时间（即还需要的CPU时间），以及状态（即用W表示等待，R表示运行，F表示完成）实验程序：#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[10];/*进程标识符*/int prio;/*进程优先数*/int round;/*进程时间轮转时间片*/int cputime; /*进程占用CPU时间*/int needtime; /*进程到完成还要的时间*/int count;/*计数器*/char state; /*进程的状态*/struct node *next; /*链指针*/}PCB;PCB *finish,*ready,*tail,*run; //队列指针int N,t; //进程数,时间片的大小void firstin(){run=ready;//就绪队列头指针赋值给运行头指针run->state='R'; //进程状态变为运行态ready=ready->next; //就绪队列头指针后移到下一进程}void prt1(char a)//输出标题函数{if(toupper(a)=='P')//优先级法printf("进程名占用CPU时间到完成还要的时间轮转时间片状态\n");} void prt2(char a,PCB *q)//进程PCB输出{if(toupper(a)=='P')//优先级法的输出printf("%4s %8d %12d %14d %8c\n",q->name,q->cputime,q->needtime,q->roun d,q->state);}void prt(char algo)//输出函数二、三、{PCB *p;prt1(algo);//输出标题if(run!=NULL)//如果运行指针不空prt2(algo,run);//输出当前正在运行的PCBp=ready;//输出就绪队列PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}p=finish;//输出完成队列的PCBwhile(p!=NULL){prt2(algo,p);p=p->next;}getchar(); //按住任意键继续}void insert(PCB *q)//时间片轮转的插入算法{PCB *p1,*s,*r;s=q;//待插入的PCB指针p1=ready;//就绪队列头指针r=p1;//*r做pl的前驱指针while(p1!=NULL)if(p1->round<=s->round){r=p1;p1=p1->next;}if(r!=p1){r->next=s;s->next=p1;}else{s->next=p1;//否则插入在就绪队列的头ready=s;}}void create(char alg)//时间片轮转法创建链表进程PCB{PCB *p;int i,time;char na[10];ready=NULL;finish=NULL;run=NULL;printf("输入进程名及其需要运行的时间(中间以空格隔开)：\n"); for(i=1;i<=N;i++){p=new PCB;scanf("%s %d",&na,&time);strcpy(p->name,na);p->cputime=0;p->needtime=time;p->state='W';//进程的状态p->round=0;if(ready!=NULL)insert(p);else{p->next=ready;ready=p;}}printf("*************时间片轮转法进程调度过程*************\n"); prt(alg);run=ready;ready=ready->next;run->state='R';}void timeslicecycle(char alg)//时间片轮转法{while(run!=NULL){run->cputime=run->cputime+t;//处理时间加trun->needtime=run->needtime-t;//完成需要时间减trun->round=run->round+t;//运行完将其变为完成态，插入完成队列if(run->needtime<=0)//当进程完成时{run->next=finish;finish=run;run->state='F';run=NULL;if(ready!=NULL)//就绪队列不空，将第一个进程投入进行firstin();}else{run->state='W';//将进程插入到就绪队列中等待轮转insert(run);//将就绪队列的第一个进程投入运行firstin();}prt(alg);}}void main()//主函数{char algo='P';//算法标记printf("输入进程的个数：");scanf("%d",&N);//输入进程数printf("定义时间片大小：");scanf("%d",&t);//输入时间片大小create(algo);//创建进程timeslicecycle(algo);//时间片轮转法调度}//main()四、实验结果：五、实验小结：时间片轮转调度是一种最古老，最简单，最公平且使用最广的算法。
操作系统原理实验
操作系统原理实验一、实验目的本实验旨在通过实际操作，加深对操作系统原理的理解，掌握操作系统的基本功能和调度算法。
二、实验环境1. 操作系统：Windows 102. 虚拟机软件：VirtualBox3. 实验工具：C语言编译器（如gcc）、汇编语言编译器（如nasm）、调试器（如gdb）三、实验内容1. 实验一：进程管理在这个实验中，我们将学习如何创建和管理进程。
具体步骤如下：a) 创建一个C语言程序，实现一个简单的计算器功能。
该计算器能够进行基本的加减乘除运算。
b) 使用fork()系统调用创建一个子进程，并在子进程中执行计算器程序。
c) 使用wait()系统调用等待子进程的结束，并获取子进程的退出状态。
2. 实验二：内存管理在这个实验中，我们将学习如何进行内存管理。
具体步骤如下：a) 创建一个C语言程序，模拟内存分配和释放的过程。
该程序能够动态地分配和释放内存块。
b) 使用malloc()函数分配一块内存，并将其用于存储数据。
c) 使用free()函数释放已分配的内存块。
3. 实验三：文件系统在这个实验中，我们将学习如何进行文件系统的管理。
具体步骤如下：a) 创建一个C语言程序，实现一个简单的文件系统。
该文件系统能够进行文件的创建、读取、写入和删除操作。
b) 使用open()系统调用打开一个文件，并进行读取和写入操作。
c) 使用unlink()系统调用删除一个文件。
四、实验步骤1. 安装虚拟机软件VirtualBox，并创建一个虚拟机。
2. 在虚拟机中安装操作系统Windows 10。
3. 在Windows 10中安装C语言编译器、汇编语言编译器和调试器。
4. 根据实验内容，编写相应的C语言程序并保存。
5. 在命令行中使用gcc编译C语言程序，并生成可执行文件。
6. 运行可执行文件，观察程序的执行结果。
7. 根据实验要求，进行相应的操作和测试。
8. 完成实验后，整理实验报告，包括实验目的、实验环境、实验内容、实验步骤和实验结果等。
电大操作系统实验报告3_ 进程管理实验
电大操作系统实验报告3_ 进程管理实验电大操作系统实验报告 3 进程管理实验一、实验目的进程管理是操作系统的核心功能之一，本次实验的目的是通过实际操作和观察，深入理解进程的概念、状态转换、进程调度以及进程间的通信机制，掌握操作系统中进程管理的基本原理和方法，提高对操作系统的整体认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C 语言，开发工具为 Visual Studio 2019。
三、实验内容及步骤（一）进程的创建与终止1、编写一个 C 程序，使用系统调用创建一个子进程。
2、在父进程和子进程中分别输出各自的进程 ID 和父进程 ID。
3、子进程执行一段简单的计算任务，父进程等待子进程结束后输出结束信息。
以下是实现上述功能的 C 程序代码：｀｀｀cinclude ＜stdioh>include ＜stdlibh>include ＜unistdh>int main(）｛pid_t pid;pid ＝ fork(）；if （pid ＜ 0) ｛printf(＂创建子进程失败\n"）；return 1;｝ else if （pid ＝＝ 0) ｛printf(＂子进程：我的进程 ID 是％d，父进程 ID 是％d\n"，getpid(）， getppid(））；int result ＝ 2 ＋ 3;printf(＂子进程计算结果：2 ＋ 3 ＝％d\n"， result)；exit(0)；｝ else ｛printf(＂父进程：我的进程 ID 是％d，子进程 ID 是％d\n"，getpid(）， pid)；wait(NULL)；printf(＂子进程已结束\n"）；｝return 0;｝｀｀｀编译并运行上述程序，可以观察到父进程和子进程的输出信息，验证了进程的创建和终止过程。
（二）进程的状态转换1、编写一个 C 程序，创建一个子进程，子进程进入睡眠状态一段时间，然后被唤醒并输出状态转换信息。
操作系统实验3进程的创建控制实验
操作系统实验3进程的创建控制实验实验三的目标是通过实现一个进程控制程序，来加深我们对进程创建和控制机制的理解，并通过实践来熟悉和掌握相关的编程技巧。
在进行实验之前，我们需要先了解进程的一些基本概念和相关知识。
首先，进程的创建是通过操作系统中的系统调用来完成的。
在Linux系统中，常用的创建进程的系统调用有fork(和exec(。
fork(系统调用可以创建一个新的进程，该进程与调用fork(的进程几乎完全相同；而exec(系统调用则在新创建的进程中执行一个新的程序。
另外，进程的控制机制主要是通过进程的状态来实现的。
进程可以处于就绪状态、运行状态和阻塞状态。
就绪状态的进程可以被调度器选择后立即运行，而阻塞状态的进程则需要等待一些条件满足后才能被唤醒并变为就绪状态。
实验三的具体内容包括：1. 编写一个程序，通过调用fork(创建多个子进程。
子进程和父进程可以并行执行，共享程序的代码和数据段。
2. 子进程通过调用exec(系统调用执行不同的程序。
可以通过调用不同的exec(函数或者传入不同的参数来执行不同的程序。
3. 子进程执行的程序可能会产生不同的结果，比如输出不同的字符串或者产生不同的返回值。
我们可以通过wait(系统调用等待子进程退出，并获取子进程的返回值。
4. 父进程可以通过调用waitpid(系统调用来选择等待一些特定的子进程，以及获取特定子进程的返回值。
通过实验三的实践，我将更加深入地了解进程的创建和控制机制。
实验三的实验结果将让我熟悉和掌握相关的编程技巧，为我今后更加熟练地编写和控制进程打下坚实的基础。
总之，实验三是一个非常有意义的实验，将帮助我更加深入地理解进程的创建和控制机制，并通过实践获得相关的编程技巧。
这将对我今后的学习和实践有很大的帮助。
16207318邓嘉操作系统实验三
操作系统实验第三次实验进程同步实验指导老师：***学号：********姓名：***操作系统第三次实验进程同步实验指导老师：谭朋柳学生：16207318邓嘉4.1 实验目的加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。
了解Linux 系统中IPC 进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。
4.2 实验说明在linux 系统中可以利用进程间通信（interprocess communication ）IPC 中的3 个对象：共享内存、信号灯数组、消息队列，来解决协作并发进程间的同步与互斥的问题。
1）共享内存是OS 内核为并发进程间交换数据而提供的一块内存区（段）。
如果段的权限设置恰当，每个要访问该段内存的进程都可以把它映射到自己私有的地址空间中。
如果一进程更新了段中数据，那么其他进程立即会看到这一更新。
进程创建的段也可由另一进程读写。
linux 中可用命令ipcs -m 观察共享内存情况。
$ ipcs -m------ Shared Memory Segments --------key shmid owner perms bytes nattch status 0x00000000 327682 student 600 393216 2 dest0x00000000 360451 student 600 196608 2 dest 0x00000000 393220 student 600 196608 2 destkey 共享内存关键值shmid 共享内存标识owner 共享内存所由者（本例为student）perm 共享内存使用权限(本例为student 可读可写）byte 共享内存字节数nattch 共享内存使用计数status 共享内存状态上例说明系统当前已由student 建立了一些共享内存,每个都有两个进程在共享。
操作系统原理实验报告
《操作系统原理》实验报告班级::学号:指导老师：目录:实验题目：实验一线程创建与撤销 (2)实验题目：实验二线程同步 (6)实验题目：实验三线程互斥 (11)实验题目：实验四进程通信 (17)实验题目：实验五读者-写者问题 (22)实验题目：实验六进程调度 (38)实验题目：实验七存储管理之动态库 (52)实验题目：实验八存储管理之存分配 (57)实验题目：实验九存储管理之页面置换算法 (70)实验题目：实验十设备管理 (85)实验题目：实验十一文件管理之文件读写 (99)实验题目：实验一线程创建与撤销完成人：XXX报告日期：2018年3月31日一、实验容简要描述（1）熟悉VC++、Visual Studio开发环境。
（2）使用相关函数创建和撤销线程。
（3）在一个进程中创建3个线程，名字分别为threada、threadb、threadc。
threada输出“hello world! ”。
threadb输出“My name is …”。
threadc输出“Please wait…”，然后sleep 5秒钟，接着输出“I wake up”。
二、程序设计1、设计思路该函数创建一个在调用进程的地址空间中执行的线程。
2、主要数据结构HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParameter,DWORD dwCreationFlags,LPDWORD lpThreadId)；VOID ExitThread(DWORD dwExitCode)；VOID Sleep(DWORD dwMilliseconds);VOID Sleep(DWORD dwMilliseconds);三、实验结果1、基本数据lpThreadAttributes：指向一个SECURITY_ATTRIBUTES结构，该结构决定了返回的句柄是否可被子进程继承。
实验三 Linux操作系统安全实验 (一)
实验三Linux操作系统安全一、实验目的及要求（一）实验目的通过实验熟悉Linux环境下的用户管理、进程管理以及文件管理的相关操作命令。
掌握linux操作系统中相关的系统安全配置方法，建立linux操作系统的基本安全框架。
（二）实验要求根据实验中介绍的Linux操作系统的各项安全性实验要求，详细观察记录设置前后系统的变化，给出分析报告。
使用RPM对系统的软件进行管理，验证系统内软件的完整性，并分析结果。
试比较Linux下网了服务安全设置与Windows下安全设置异同。
二、实验环境安装Red hat9.0操作系统的计算机一台三、实验内容1、账户和口令安全2、文件系统管理安全3、查看和更改PAM模块设置4、RPM软件管理5、系统安全配置四、实验步骤任务一账户和口令安全1、查看和添加账户（1）在X_Windows窗口中单击鼠标右键，选择“信件中断”，输入下面的命令行：[root@localhost root]#useradd mylist利用useradd命令新建名为mylist的新账户。
（2）输入命令行：[root@localhost root]#cat/etc/shadow利用cat查看系统中的账户列表。
用su命令切换到新建的账户，重复步骤（2），检查shadow文件的权限设置是否安全。
设置安全时，普通用户mylist应该没有查看该系统文件的权限。
在终端中出现如下的提示：Cat:/etc/shadow:权限不够2、添加和更改密码（1）在终端输入[root@localhost root]#passwd mylist为新建账户添加密码。
注意：系统管理员无需输入原来密码即可以利用passwd命令添加或改变任意用户的密码，但普通用户只能改变自己的密码。
（2）输入后依次出现如下提示：Changjing passwd for user mylist.New passwd:Retype new passwd:Passwd:all authentication tokens updated susscessfully.输入密码，Linux系统不会将输入显示出来。
清华大学操作系统lab3实验报告范文
清华大学操作系统lab3实验报告范文实验3：虚拟内存管理练习1：给未被映射的地址映射上物理页ptep=get_pet(mm->dir,addr,1);if(ptep==NULL){//页表项不存在cprintf("get_pteindo_pgfaultfailed\n"); gotofailed;}if(某ptep==0){//物理页不在内存之中//判断是否可以分配新页if(pgdir_alloc_page(mm->pgdir,addr,perm)==NULL){ cprintf("pgdir_alloc_pageindo_pgfaultfailed\n"); gotofailed;}}ele{if(wap_init_ok){tructPage某page=NULL;ret=wap_in(mm,addr,&page);if(ret!=0){//判断页面可否换入cprintf("wap_inindo_pgfaultfailed\n");gotofailed;}//建立映射page_inert(mm->pgdir,page,addr,perm);wap_map_wappable(mm,addr,page,1);}ele{cprintf("nowap_init_okbutptepi%某,failed\n",某ptep); gotofailed;}}ret=0;failed:returnret;}练习2：补充完成基于FIFO算法_fifo_map_wappable(tructmm_truct某mm,uintptr_taddr,tructPage某page,intwap_in){lit_entry_t某head=(lit_entry_t某)mm->m_priv;lit_entry_t某entry=&(page->pra_page_link);aert(entry!=NULL&&head!=NULL);lit_add(head,entry);return0;}pra_page_link用来构造按页的第一次访问时间进行排序的一个链表，这个链表的开始表示第一次访问时间最近的页，链表的尾部表示第一次访问时间最远的页。
操作系统实验报告三存储器管理实验
操作系统实验报告三存储器管理实验操作系统实验报告三：存储器管理实验一、实验目的本次存储器管理实验的主要目的是深入理解操作系统中存储器管理的基本原理和方法，通过实际操作和观察，掌握内存分配与回收的算法，以及页面置换算法的工作过程和性能特点，从而提高对操作系统资源管理的认识和实践能力。
二、实验环境本次实验使用的操作系统为 Windows 10，编程语言为 C+＋，开发工具为 Visual Studio 2019。
三、实验内容1、内存分配与回收算法实现首次适应算法（First Fit）最佳适应算法（Best Fit）最坏适应算法（Worst Fit）2、页面置换算法模拟先进先出页面置换算法（FIFO）最近最久未使用页面置换算法（LRU）时钟页面置换算法（Clock）四、实验原理1、内存分配与回收算法首次适应算法：从内存的起始位置开始，依次查找空闲分区，将第一个能够满足需求的空闲分区分配给进程。
最佳适应算法：在所有空闲分区中，选择能够满足需求且大小最小的空闲分区进行分配。
最坏适应算法：选择空闲分区中最大的分区进行分配。
2、页面置换算法先进先出页面置换算法：选择最早进入内存的页面进行置换。
最近最久未使用页面置换算法：选择最近最长时间未被访问的页面进行置换。
时钟页面置换算法：给每个页面设置一个访问位，在页面置换时，从指针指向的页面开始扫描，选择第一个访问位为0 的页面进行置换。
五、实验步骤1、内存分配与回收算法实现定义内存分区结构体，包括分区起始地址、大小、是否已分配等信息。
实现首次适应算法、最佳适应算法和最坏适应算法的函数。
编写测试程序，创建多个进程，并使用不同的算法为其分配内存，观察内存分配情况和空闲分区的变化。
2、页面置换算法模拟定义页面结构体，包括页面号、访问位等信息。
实现先进先出页面置换算法、最近最久未使用页面置换算法和时钟页面置换算法的函数。
编写测试程序，模拟页面的调入和调出过程，计算不同算法下的缺页率，比较算法的性能。
操作系统实验进程调度
实验三进程调度一. 实验目的加深理解并模拟实现进程（作业）调度算法。
1）熟悉常用的进程调度算法, 如FCFS、SPF、FPF、高响应比优先、时间片轮转；2）结合所学的数据结构及编程知识, 选择三种进程调度算法予以实现。
二. 实验属性该实验为设计性实验。
三. 实验仪器设备及器材普通PC386以上微机四. 实验要求本实验要求2学时完成。
1）本实验要求完成如下任务:2）编程实现单处理机系统中的进程调度, 要求从FCFS、SPF、FPF、高响应比优先、时间片轮转算法中至少选择三个；3）最后编写主函数对所做工作进行测试。
实验前应复习实验中所涉及的理论知识和算法, 针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。
实验后认真书写符合规范格式的实验报告（参见附录A）, 并要求用正规的实验报告纸和封面装订整齐, 按时上交。
五: 实验具体设计此程序模拟了两种调度算法, FCFS和SPF, 首先FCFS就是按照进程的创建顺序依次顺序进行, 流程图为：进程顺序执行SPF:每次都进行循环, 选出在该时间刻运行时间最短的进程优先执行。
1.程序代码具体详解:2.创建一结构体作为进程控制器typedef struct PCB{int ID;char state;int arrivetime;int starttime;int finishtime;int servicetime;struct PCB *next;}pcb;定义全局变量作为计时器int time;//计时器创建进程链表:从txt文件中读取数据, 构造一条不含头结点的单链表void Create_process(){ifstream inFile;inFile.open("test.txt");inFile>>n;inFile.get();int i=0;for (;i<n;i++){p=(pcb *)malloc(sizeof(pcb));inFile>>p->ID;inFile>>p->arrivetime;inFile>>p->servicetime;p->starttime=0;p->finishtime=0;p->state='F';p->next=NULL;if(head==NULL){head=p;q=p;time=p->arrivetime;}if(p->arrivetime < time)time=p->arrivetime;q->next=p;q=p;}若执行FCFS算法, 按顺序遍历链表void fcfs1(){int i;p=head;for(i=0;i<n;i++){if(p->state=='F')q=p;run_fcfs1(q);}p=p->next;}}void run_fcfs1(pcb *p1){time = p1->arrivetime > time? p1->arrivetime:time;p1->starttime=time;printf("\n现在时间: %d,开始运行作业%d\n",time,p1->ID);time+=p1->servicetime;p1->state='T';p1->finishtime=time;printf("ID号到达时间开始运行时间服务时间完成时间\n");printf("%d%10d%12d%12d%12d\n",p1->ID,p1->arrivetime,p1->starttime,p1->servicetime,p 1->finishtime);}若执行SPF算法, 每次都从链表头开始遍历链表, 找出arrivetime<=time并且运行时间最短的节点, 执行该节点进程, 最后再删除该节点。
操作系统实验报告三
操作系统实验报告三一、实验目的本次操作系统实验的目的在于深入了解操作系统的进程管理、内存管理和文件系统等核心功能，通过实际操作和观察，增强对操作系统原理的理解和掌握，提高解决实际问题的能力。
二、实验环境本次实验在 Windows 10 操作系统环境下进行，使用了 Visual Studio 2019 作为编程工具，并借助了相关的操作系统模拟软件和调试工具。
三、实验内容与步骤（一）进程管理实验1、创建多个进程使用 C+＋语言编写程序，通过调用系统函数创建多个进程。
观察每个进程的运行状态和资源占用情况。
2、进程同步与互斥设计一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
分析在不同并发情况下程序的执行结果，理解进程同步的重要性。
（二）内存管理实验1、内存分配与回收实现一个简单的内存分配算法，如首次适应算法、最佳适应算法或最坏适应算法。
模拟内存的分配和回收过程，观察内存的使用情况和碎片产生的情况。
2、虚拟内存管理了解 Windows 操作系统的虚拟内存机制，通过查看系统性能监视器观察虚拟内存的使用情况。
编写程序来模拟虚拟内存的页面置换算法，如先进先出（FIFO）算法、最近最少使用（LRU）算法等。
（三）文件系统实验1、文件操作使用 C+＋语言对文件进行创建、读写、删除等操作。
观察文件在磁盘上的存储方式和文件目录的结构。
2、文件系统性能测试对不同大小和类型的文件进行读写操作，测量文件系统的读写性能。
分析影响文件系统性能的因素，如磁盘碎片、缓存机制等。
四、实验结果与分析（一）进程管理实验结果1、创建多个进程在创建多个进程的实验中，通过任务管理器可以观察到每个进程都有独立的进程 ID、CPU 使用率、内存占用等信息。
多个进程可以并发执行，提高了系统的资源利用率。
2、进程同步与互斥在生产者消费者问题的实验中，当使用正确的信号量机制时，生产者和消费者能够协调工作，不会出现数据不一致或死锁的情况。
操作系统实验
操作系统实验报告（一）Linux基本操作与编程（验证性 2学时）1、实验目(de)：1）熟悉Linux操作系统(de)环境和使用.2）了解LINUX系统(de)安装过程.（注：表示可选择）3）掌握Linux环境下(de)命令操作.2、实验内容：（1）完成LINUX系统(de)登录,启动终端.进行下列操作并记录结果(要求：结果以屏幕截图表示).1）运行pwd命令,确定你当前(de)工作目录.2）利用以下命令显示当前工作目录(de)内容： ls –l3）运行以下命令： ls –al4）使用mkdir命令建立一个子目录subdir.5）使用cd命令,将工作目录改到根目录（/）上.6）使用ls-l命令列出/dev(de)内容.7）使用不带参数(de)命令cd改变目录,然后用pwd命令确定你当前(de)工作目录是哪里8）使用命令cd ../..,你将工作目录移到什么地方（2）在LINUX下查看你(de)文件.1）利用cd命令,将工作目录改到你(de)主目录上.2）将工作目录改到你(de)子目录subdir,然后运行命令： date > file1 将当前日期和时间存放到新建文件file1中.3）使用cat命令查看file1文件(de)内容.4）利用man命令显示date命令(de)用法： man date5）将date命令(de)用法附加到文件file1(de)后面：man date >> file16）利用cat命令显示文件file1(de)内容.7）利用ls -l file1命令列出文件file1(de)较详细(de)信息.运行ls -l/bin 命令显示目录(de)内容.8）利用ls -l/bin|more命令行分屏显示/bin目录(de)内容.9）利用cp file1 fa命令生成文件file1(de)副本.然后利用ls -l命令查看工作目录(de)内容.10）用cd命令返回你(de)主目录,输入命令ls –l后,解释屏幕显示(de)第一列内容(de)含义.（3）编写能输出“Hello world”问候语(de)C程序,并在终端中编译、执行.要求记录所使用(de)命令及结果.操作步骤：1）在文本编辑器中,编写C程序如下：include ""main(){ printf("hello"); }2) 在终端中,用gcc命令进行编译,生成可执行文件a.gcc –o a3) 在终端中执行a (de)命令如下：./a（4）编写一个程序：显示信息“Time for Play”,并能在后台运行一段时间（自定义）后,弹出信息提醒用户.要求记录所使用(de)命令及结果.（提示：使用sleep(s)函数）3、实验结果分析：（对上述实验内容中(de)各题结果,进行分析讨论.并回答下列问题）（1）进程包括哪些特征间断性, 失去封闭性, 不可再现性, 动态性, 并发性, 独立性（2）在Linux中,如何设置前、后台命令和程序(de)执行命令后直接加 & ,这个命令就在后台执行；正在运行(de)命令,使用Ctrl+z ,就挂起； jobs命令,可以现实后台,包括挂起(de)命令；使用 bg %作业号就可以把挂起(de)命令在后台执行；使用 fg %作业号就可以把后台命令调到前台（3）你所使用(de)Linux系统(de)内核版本是多少用什么命令查看内核版本目前你所了解(de)各发行版本(de)情况如何Linux version (gcc version (Red Hat (GCC) ) 1 SMP Tue Jan 2911:48:01 EST 2013（4）你对Linux系统有什么认识linux是一款开放性(de)操作系统,也可以说成是开放(de)源代码系统,这些代码可以完全自由(de)修改可以再任何(de)计算机上去运行它,也就是“可移植性”,其次大家都知道,linux是由UNIX(de)概念所开发出来(de),所以它也继承了UNIX(de)稳定和效率(de)特点4、总结：你对本次实验有什么体会或看法.操作系统实验报告（二）文件访问权限设置与输入输出重定向（2学时）一、实验目(de)1、掌握linux(de)文件访问权限设置.2、熟悉输入输出重定向和管道操作.二、实验内容1、启动进入红帽linux系统2、设置文件权限：在用户主目录下创建目录test,进入test目录,用vi 创建文件file1,并输入任意(de)文字内容.用ls -l显示文件信息,注意文件(de)权限和所属用户和组.对文件file1设置权限,使其他用户可以对此文件进行写操作：chmod o+w file1.用ls -l查看设置结果.取消同组用户对此文件(de)读取权限：chmod g-r file1.查看设置结果.用数字形式来为文件file1设置权限,所有者可读、可写、可执行；其他用户和所属组用户只有读和执行(de)权限：chmod 755 file1.设置完成后查看设置结果.3、输入、输出重定向和管道（1) 输出重定向用ls命令显示当前目录中(de)文件列表：ls –l.使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中：ls –l > list.查看文件list中(de)内容,注意在列表中会多出一个文件list,其长度为0. 这说明shell是首先创建了一个空文件,然后再运行ls命令：cat list.再次使用输出重定向,把ls命令在终端上显示(de)当前目录中(de)文件列表重定向到文件list中.这次使用追加符号>>进行重定向：ls –l >> list.查看文件list(de)内容,可以看到用>>进行重定向是把新(de)输出内容附加在文件(de)末尾,注意其中两行list文件(de)信息中文件大小(de)区别：cat list.重复命令ls –l > list.再次查看文件list中(de)内容,和前两次(de)结果相比较,注意list文件大小和创建时间(de)区别.（2) 管道who |grep root命令(de)结果是命令ls –l |wc –l结果是4、退出linux系统操作步骤：在主菜单上选择“注销” ->关闭计算机.三、实验结果与讨论（根据实验结果回答下列问题）1. 文件(de)权限如下：-rw-r—r-- 1 root root 19274 Jul 14 11:00回答：-rw-r—r-- (de)含义是什么答：是LINUX/FTP(de)简易权限表示法：对应于本用户-所在组-其他人(de)权限,每一个用执行（x）-读取(r)-写入(w)如本题若是说自己可以读取写入不可以执行,所在组和其他人只能读取.2、文件(de)所有者添加执行权限(de)命令是答：chmod u+x 、赋予所有用户读和写文件权限(de)命令是四、答：chmod a+w,a+r 个人体会（你对本次实验有什么体会或看法）操作系统实验报告（三）文件和目录管理一、实验目(de)1) 掌握在Linux系统下(de)文件和文件系统(de)概念及命令；2) 掌握Linux系统下(de)目录操作.二、实验内容1. 进入linux终端后,用命令(de)操作结果回答下列问题：1）vi(de)三种工作模式是其中不能进行直接转换(de)是什么模式到什么模式命令模式、文本输入模式、末行模式命令模式不能直接到末行模式2）在vi中退出时,保存并退出(de)操作步骤是Ese：wq3）用vi 创建myfile1文件,并在其中输入任意文字一行,创建myfile2文件,任意输入文字3行.请问执行命令：cat <myfile1 >myfile2 后,myfile2中还有几行内容该命令(de)作用是用命令操作验证你(de)回答.myfile2中还有1行内容该命令(de)作用是替换myfile(de)内容4）请用至少两种不同(de)命令创建一个文本文件（）,在其中写入“我是2014级学生,我正在使用Linux系统.”,记录命令及执行结果.1、Vi创建2、5)用___pwd________命令可查看所创建文件(de)绝对路径,写出它(de)绝对路径__/root_________；用___ls -l________命令查看该文件(de)类型及访问权限,其访问权限（数字和字母）分别是多少__-rw- r- - r- - 6 4 4______________.6）若将该文件(de)访问权限修改为：所有者有读写权限；其他用户只读；同组用户可读写,请写出命令,并记录结果.7）查找my开头(de)所有文件,可___find my_________命令,写出命令并记录结果8）在/home下创建子目录user,并在其中创建2个文件,名为file1和file2,file1(de)内容是/root目录(de)详细信息；file2(de)内容任意,最后将这两个文件合并为file3文件,请先写出命令序列,并在终端中验证,记录结果.2. 文件及目录操作,写出操作所使用(de)命令,并记录结果.在终端中完成下列命令操作,并记录结果在root用户主目录下创建一个mydir子目录和一个myfile文件,再在mydir下建立d1和d2两个子目录.查看mydir和myfile(de)默认权限查看当前myfile和mydir(de)权限值是多少将myfile文件分别复制到root 和dd1(de)主目录中将root主目录中(de)myfile改为yourfile通过从键盘产生一个新文件并输入I am a student查找文件是否包含student字符串三、实验结果与分析,回答下列问题：1、能够创建文件(de)命令有哪些vi 和cat>name2、能够查看当前目录(de)绝对路径(de)命令是pwd3、Linux中按用户属性将用户分成哪些类型根据文件(de)访问权限,用户又被分成哪些类型能够查看文件访问权限(de)命令是用户同组其他可读可写可执行 cat f1四、小结（本次实验(de)体会或小结）操作系统实验报告（四）作业调度算法模拟（验证性2学时）1、实验目(de)：1)掌握作业调度(de)主要功能及算法.2)通过模拟作业调度算法(de)设计加深对作业管理基本原理(de)理解.3)熟悉Linux环境下应用程序(de)编程方法.2、实验内容：（1）作业调度算法（FCFS）编程模拟：编制一段程序,对所输入(de)若干作业,输入、输出数据样例如下表所示.按FCFS算法模拟调度,观察、记录并分析调度(de)输出结果情况.输入输出样例1：FCFS算法include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void fcfs(){ int i,j,t=0,tw=0,tt=0;for(i=0;i<SIZE-1;i++)for(j=i+1;j<SIZE;j++)if(job[i].tb>job[j].tb){x=job[i];job[i]=job[j];job[j]=x;}printf("FCFS调度结果:\n");printf("开始时间作业号到达时间运行时间完成时间等待时间周转时间\n");for(i=0;i<SIZE;i++){printf(" %d",t);t=t+job[i].tr;tw=t-job[i].tb-job[i].tr; b; o,job[i].tb,job[i].tr,t,tw,tt);}}void main(){load();fcfs();}（2）作业调度算法（SJF）编程模拟：编程实现由短作业优先算法,分别用下面两组输入、输出数据样例进行模拟,观察分析运行结果.输入输出样例2：SJF算法输入输出A 0 4B 0 3C 0 5D 0 2E 0 1A 0 6 10 10B 0 3 6 6C 0 10 15 15D 0 1 3 3E 0 0 1 1include <>include <>define SIZE 5struct Job_type{char no[2]; o,&job[i].tb,&job[i].tr);printf("输入作业顺序:\n");for(i=0;i<SIZE;i++)printf("\t%s\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr);}void sjf()n=i; pl[i].pfn=ERR;}for(i=1;i<total;i++){ pfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;}pfc[total-1].next=NULL;pfc[total-1].pfn=total-1;freepf_head=&pfc[0];}void FIFO(int total){ int i,j;pfc_type p,t;initialize(total);busypf_head=busypf_tail=NULL;for(i=0;i<page_len;i++){if(pl[page[i]].pfn==ERR){ diseffect+=1;if(freepf_head==NULL){p=busypf_head->next;pl[busypf_head->pn].pfn=ERR; freepf_head=busypf_head;freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next;freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{ busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%d",diseffect);}main(){ int i; int k;printf(“请输入页(de)引用序列：\n”); for(k=0;k<page_len;k++)scanf("%d",&page[k]);for(i=4;i<=7;i++){printf("%2d page frames ",i);FIFO(i);}参考程序LRU算法,略三、实验结果分析：（对上述实验各题所使用(de)原始数据、调试数据与状态（包括出错）及最终结果进行记录并分析.）随着块数(de)增加,缺页数目也减少,4个实验中3个实验(de)块数增加到了5以后,即使块数再增加,缺页数目也是保持不变.只有实验4,块数增加到7以后,缺页数目又再次减少了四、总结：你对本次实验有什么体会或看法.。
《操作系统》实验教学大纲
《操作系统》实验教学大纲实验名称：操作系统实验实验课程：计算机科学与技术、软件工程、电子信息工程实验学时：24学时（12次课程实验）实验目的：1.通过操作系统实验，学生将深入了解操作系统的原理和设计。
2.学生将掌握操作系统的基本概念和常用技术。
3.提高学生的实践能力和创新能力，培养学生的团队合作精神。
实验内容：1.实验一：操作系统基本概念-实验介绍：了解操作系统的基本概念和基本功能。
-实验要求：学生通过阅读文献或参考书籍，掌握操作系统的基本概念。
-实验过程：学生通过讨论或小组讨论的方式，给出操作系统的定义和基本功能列表。
2.实验二：进程管理-实验介绍：通过实验来学习进程管理的基本概念和常用算法。
-实验要求：学生通过自己编写程序，实现进程的创建、销毁和调度。
-实验过程：学生根据给定的问题，设计进程模型并实现相应的程序。
3.实验三：内存管理-实验介绍：了解内存管理的基本概念和常用算法，学习虚拟内存技术的原理。
-实验要求：学生通过编写程序，实现内存分配和回收的算法。
-实验过程：学生通过模拟内存分配和回收的过程，理解内存管理的基本原理。
4.实验四：文件系统-实验介绍：了解文件系统的基本概念和常用算法，学习文件管理的基本原理。
-实验要求：学生通过编写程序，实现文件的创建、删除和查找。
-实验过程：学生通过模拟文件的创建、删除和查找的过程，理解文件管理的基本原理。
5.实验五：设备管理-实验介绍：通过实验学习设备管理的基本概念和常用算法，了解设备驱动程序的实现原理。
-实验要求：学生通过编写程序，模拟设备的控制和管理。
-实验过程：学生通过模拟设备的请求、分配和释放的过程，理解设备管理的基本原理。
6.实验六：作业调度-实验介绍：通过实验学习作业调度的基本概念和常用算法。
-实验要求：学生通过编写程序，实现作业的调度。
-实验过程：学生通过输入作业和作业调度算法，模拟作业调度的过程。
实验评定：-实验报告：60%-实验成果：20%-实验操作：20%实验环境：- 操作系统：Linux、Windows实验要求：-学生需认真完成实验任务，编写实验报告。
操作系统实验报告实验3_1
操作系统实验报告实验3_1一、实验目的本次实验的主要目的是深入理解操作系统中进程管理的相关概念和原理，通过实际操作和观察，掌握进程的创建、调度、同步与互斥等关键机制，提高对操作系统内核工作原理的认知和实践能力。
二、实验环境本次实验在装有 Windows 10 操作系统的计算机上进行，使用了Visual Studio 2019 作为开发工具，编程语言为 C+＋。
三、实验内容与步骤（一）进程创建1、编写一个简单的 C+＋程序，使用系统调用创建一个新的进程。
2、在父进程和子进程中分别输出不同的信息，以区分它们的执行逻辑。
｀｀｀cppinclude ＜iostream>include ＜windowsh>int main(）｛DWORD pid;HANDLE hProcess ＝ CreateProcess(NULL, ＂childexe"， NULL, NULL, FALSE, 0, NULL, NULL, NULL, ＆pid)；if （hProcess!＝ NULL) ｛std:：cout ＜＜＂Parent process: Created child process with PID ＂＜＜ pid ＜＜ std:：endl;WaitForSingleObject(hProcess, INFINITE)；CloseHandle(hProcess)；｝ else ｛std:：cerr ＜＜＂Failed to create child process" ＜＜ std:：endl;return 1;｝return 0;｝｀｀｀（二）进程调度1、设计一个多进程并发执行的程序，通过设置不同的优先级，观察操作系统对进程的调度情况。
2、记录每个进程的执行时间和等待时间，分析调度算法的效果。
｀｀｀cppinclude ＜iostream>include ＜windowsh>DWORD WINAPI ProcessFunction(LPVOID lpParam) ｛int priority ＝（int)lpParam;DWORD start ＝ GetTickCount(）；std:：cout ＜＜＂Process with priority ＂＜＜ priority ＜＜＂started" ＜＜ std:：endl;for （int i ＝ 0; i ＜ 100000000; i+＋）｛／／执行一些计算操作｝DWORD end ＝ GetTickCount(）；DWORD executionTime ＝ end start;std:：cout ＜＜＂Process with priority ＂＜＜ priority ＜＜＂ ended Execution time: ＂＜＜ executionTime ＜＜＂ ms" ＜＜ std:：endl;return 0;｝int main(）｛HANDLE hThread1, hThread2;int priority1 ＝ 1, priority2 ＝ 2;hThread1 ＝ CreateThread(NULL, 0, ProcessFunction, ＆priority1, 0, NULL)；hThread2 ＝ CreateThread(NULL, 0, ProcessFunction, ＆priority2, 0, NULL)；if （hThread1!＝ NULL ＆＆ hThread2!＝ NULL) ｛SetThreadPriority(hThread1, THREAD_PRIORITY_LOWEST)；SetThreadPriority(hThread2, THREAD_PRIORITY_NORMAL)；WaitForSingleObject(hThread1, INFINITE)；WaitForSingleObject(hThread2, INFINITE)；CloseHandle(hThread1)；CloseHandle(hThread2)；｝ else ｛std:：cerr ＜＜＂Failed to create threads" ＜＜ std:：endl;return 1;｝return 0;｝｀｀｀（三）进程同步与互斥1、实现一个生产者消费者问题的程序，使用信号量来实现进程之间的同步与互斥。
网络操作系统 实验作业3参考答案
实验作业3【问题与思考】1、在Linux系统中，哪个文件定义了用户的信息________。
A. /etc/passwdB./etc/usersC./etc/infoD./etc/resolv.conf2、在Linux系统中，如何获取命令“iostat”的帮助信息_______。
A．man iostat B．? –k iostatC．help iostat D．sos -iostat3、下列哪个命令可以将输出到标准输出设备上的信息保存到文件 /tmp/user.dat 中________。
A. > /tmp/user.datB. < /tmp/user.datC. ! /tmp/user.datD. % /tmp/user.dat4、Linux系统中，哪个文件保存了用户账户的加密口令信息_______。
A./etc/securityB./etc/shadowC./etc/passwdD. /etc/inittab5、在Linux中，命令解释器是哪个。
A、管道B、分级文件系统C、字符型处理器D、 shell6、在Linux中，要删除abc目录及其全部内容的命令为。
A、rm abcB、rm -r abcC、rmdir abcD、rmdir -r abc7、请选出创建用户ID是200，组ID是1000，用户主目录为/home/user01的新用户user01的正确命令是：。
A、adduser -u:200 -g:1000 -h:/home/user01 user01B、adduser -u=200 -g=1000 -d=/home/user01 user01C、useradd -u 200 -g 1000 -d /home/user01 user01D、useradd -u 200 -g 1000 -h /home/user01 user018、Linux操作系统中的shell是。
A、命令解释器B、程序设计语言C、脚本编辑器D、编译器9、CentOS系统中用户默认的Shell是。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告哈尔滨工程大学计算机科学与技术学院第三讲进程的创建一、实验概述1. 实验名称进程的创建2. 实验目的● 练习使用EOS API函数CreateProcess创建一个进程，掌握创建进程的方法，理解进程和程序的区别。
● 调试跟踪CreateProcess函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。
3. 实验类型设计4. 实验内容4.1 准备实验按照下面的步骤准备本次实验：1. 启动OS Lab。
2. 新建一个EOS Kernel项目。
3. 分别使用Debug配置和Release配置生成此项目，从而在该项目文件夹中生成完全版本的EOS SDK文件夹。
4. 新建一个EOS应用程序项目。
5. 使用在第3步生成的SDK文件夹覆盖EOS应用程序项目文件夹中的SDK文件夹。
4.2 练习使用控制台命令创建EOS应用程序的进程练习使用控制台命令创建EOS应用程序进程的具体步骤如下：1. 在EOS应用程序项目的“项目管理器”窗口中双击Floppy.img文件，使用FloppyImageEditor工具打开此软盘镜像文件。
2. 将本实验文件夹中的Hello.exe文件拖动到FloppyImageEditor工具窗口的文件列表中释放，Hello.exe文件即被添加到软盘镜像文件中。
Hello.exe一个EOS应用程序，其源代码可以参见本实验文件夹中的Hello.c源文件。
3. 在FloppyImageEditor中选择“文件”菜单中的“保存”后关闭FloppyImageEditor。
4. 按F7生成EOS应用项目。
5. 按F5启动调试。
OS Lab会弹出一个调试异常对话框，并中断应用程序的执行。
6. 在调试异常对话框中选择“否”，忽略异常继续执行应用程序。
7. 激活虚拟机窗口，待该应用程序执行完毕后，在EOS的控制台中输入命令“A:\Hello.exe”后回车。
8. Hello.exe应用程序开始执行，观察其输出。
9. 待Hello.exe执行完毕后可以重复第7步，或者结束此次调试。
4.3 练习通过编程的方式让应用程序创建另一个应用程序的进程使用OS Lab打开本实验文件夹中的NewProc.c文件（将此文件拖动到OS Lab窗口中释放即可），仔细阅读此文件中的源代码和注释。
按照下面的步骤查看应用程序创建另一个应用程序的进程的执行结果：1. 使用NewProc.c文件中的源代码替换之前创建的EOS应用程序项目中的EOSApp.c文件内的源代码。
2. 按F7生成修改后的EOS应用程序项目。
3. 按F5启动调试。
OS Lab会首先弹出一个调试异常对话框。
4. 在调试异常对话框中选择“否”，继续执行。
5. 激活虚拟机窗口查看应用程序输出的内容。
可以看到父进程（EOSApp.exe）首先开始执行并输出内容，父进程创建了子进程（Hello.exe）后，子进程开始执行并输出内容，待子进程结束后父进程再继续执行。
6. 结束此次调试。
4.4 调试CreateProcess函数按照下面的步骤调试CreateProcess函数创建进程的过程：1. 按F5启动调试EOS应用程序，OS Lab会首先弹出一个调试异常对话框。
2. 选择“是”调试异常，调试会中断。
3. 在main函数中调用CreateProcess函数的代码行（第57行）添加一个断点。
4. 按F5继续调试，在断点处中断。
5. 按F11调试进入CreateProcess函数。
此时已经开始进入EOS内核进行调试。
当EOS应用程序eosapp.exe存储在软盘上的时候，它是静态的，只包含应用程序的指令和数据。
而创建进程后，进程不但包含应用程序的指令和数据，也会包含操作系统内核（kernel.dll）的指令和数据（参见图5-1）。
同时，图11-4也说明了一个进程可以包含多个程序，该进程包含了eosapp.exe和kernel.dll两个程序。
可以按照下面的步骤来分别验证应用程序和操作系统内核在进程的4G虚拟地址空间中所处的位置：1. 由于此时在内核的CreateProcess函数内中断执行，所以在“调试”菜单的“窗口”中选择“反汇编”，会在“反汇编”窗口中显示CreateProcess函数的指令对应的反汇编代码。
“反汇编”窗口的左侧显示的是指令所在的虚拟地址。
可以看到所有指令的虚拟地址都大于0x80000000，说明内核（kernel.dll）处于高2G的虚拟地址空间中。
2. 在“调用堆栈”窗口中双击main函数项，设置main函数的调用堆栈帧为活动的。
在“反汇编”窗口中查看main函数的指令所在的虚拟地址都是小于0x80000000，说明应用程序（eosapp.exe）处于低2G的虚拟地址空间中。
3. 在“调用堆栈”窗口中双击CreateProcess函数项，重新设置CreateProcess函数的调用堆栈帧为活动的。
关闭“反汇编”窗口。
接下来观察eosapi.c文件中CreateProcess函数的源代码，可以看到此函数只是调用了EOS 内核函数PsCreateProcess并将创建进程所用到的参数传递给了此函数。
所以，按F11可以调试进入create.c文件中的PsCreateProcess函数，在此函数中才开始执行创建进程的各项操作。
4.5 调试PsCreateProcess函数创建进程最主要的操作就是创建进程控制块(PCB),并初始化其中的各种信息（也就是为进程分配各种资源）。
所以在PsCreateProcess函数中首先调用了PspCreateProcessEnvironment 函数来创建进程控制块。
调试PspCreateProcessEnvironment函数的步骤如下：1. 在PsCreateProcess函数中找到调用PspCreateProcessEnvironment函数的代码行（create.c文件的第163行），并在此行添加一个断点。
2. 按F5继续调试，到此断点处中断。
3. 按F11调试进入PspCreateProcessEnvironment函数。
由于PspCreateProcessEnvironment函数的主要功能是创建进程控制块并初始化其中的部分信息，所以在此函数的开始，定义了一个进程控制块的指针变量NewProcess。
在此函数中查找到创建进程控制块的代码行（create.c文件的第418行）Status = ObCreateObject( PspProcessType,NULL,sizeof(PROCESS) + ImageNameSize + CmdLineSize,0,(PVOID*)&NewProcess ); 这里的ObCreateObject函数会在由EOS内核管理的内存中创建了一个新的进程控制块（也就是分配了一块内存），并由NewProcess返回进程控制块的指针（也就是所分配内存的起始地址）。
按照下面的步骤调试进程控制块的创建过程：1. 在调用ObCreateObject函数的代码行（create.c文件的第418行）添加一个断点。
2. 按F5继续调试，到此断点处中断。
3. 按F10执行此函数后中断。
4. 此时为了查看进程控制块中的信息，将表达式*NewProcess添加到“监视”窗口中。
5. 将鼠标移动到“监视”窗口中此表达式的“值”属性上，会弹出一个临时窗口，在临时窗口中会按照进程控制块的结构显示各个成员变量的值（可以参考PROCESS结构体的定义）。
由于只是新建了进程控制块，还没有初始化其中成员变量，所以值都为0。
接下来调试初始化进程控制块中各个成员变量的过程：1. 首先创建进程的地址空间，即4G虚拟地址空间。
在代码行（create.c文件的第437行）NewProcess->Pas = MmCreateProcessAddressSpace(); 添加一个断点。
2. 按F5继续调试，到此断点处中断。
3. 按F10执行此行代码后中断。
4. 在“监视”窗口中查看进程控制块的成员变量Pas的值已经不再是0。
说明已经初始化了进程的4G虚拟地址空间。
根据执行的源代码，查看“监视”窗口中*NewProcess表达式的值，观察进程控制块中哪些成员变量是被哪些代码初始化的，哪些成员变量还没有被初始化。
6. 当从PspCreateProcessEnvironment函数返回到PsCreateProcess函数后，停止按F10。
此时“监视”窗口中已经不能再显示表达式*NewProcess的值了，在PsCreateProcess函数中是使用ProcessObject指针指向进程控制块的，所以将表达式*ProcessObject添加到“监视”窗口中就可以继续观察新建进程控制块中的信息。
7. 接下来继续使用F10一步步调试PsCreateProcess函数中的代码，同样要注意观察执行后的代码修改了进程控制块中的哪些成员变量。
当调试到PsCreateProcess函数的最后一行代码时，查看进程控制块中的信息，此时所有的成员变量都已经被初始化了（注意观察成员ImageName的值）。
8. 按F5继续执行，EOS内核会为刚刚初始化完毕的进程控制块新建一个进程。
激活虚拟机窗口查看新建进程执行的结果。
9. 在OS Lab中选择“调试”菜单中的“停止调试”结束此次调试。
10. 选择“调试”菜单中的“删除所有断点”。
4.6 练习通过编程的方式创建应用程序的多个进程使用OS Lab打开本实验文件夹中的参考源代码文件NewTwoProc.c，仔细阅读此文件中的源代码。
使用NewTwoProc.c文件中的源代码替换EOS应用程序项目中EOSApp.c文件内的源代码，生成后启动调试，查看多个进程并发执行的结果。
多个进程并发时，EOS操作系统中运行的用户进程可以参见图11-5。
验证一个程序（hello.exe）可以同时创建多个进程。
二、实验环境操作系统集成实验环境OS LabEOS 操作系统三、实验过程1. 设计思路和流程图2. 需要解决的问题及解答在PsCreateProcess函数中调用了PspCreateProcessEnvironment函数后又先后调用了PspLoadProcessImage和PspCreateThread函数，学习这些函数的主要功能。
能够交换这些函数被调用的顺序吗？思考其中的原因。
答：PspCreateProcessEnvironment的主要功能是创建进程控制块并且为进程创建了地址空间和分配了句柄表。
PspLoadProcessImage是将进程的可执行映像加载到了进程的地址空间中。
PspCreateThread创建了进程的主线程。
这三个函数被调用的顺序是不能够改变的就向上面描述的加载可执行映像之前必须已经为进程创建了地址空间这样才能够确定可执行映像可以被加载到内存的什么位置在创建主线程之前必须已经加载了可执行映像这样主线程才能够知道自己要从哪里开始执行，执行哪些指令。