操作系统
实验报告
哈尔滨工程大学
计算机科学与技术学院
一、实验概述
1. 实验名称
进程的创建
2. 实验目的
(1)练习使用EOS API函数CreateProcess创建一个进程，掌握创建进程的方法，理解进程和程序的区别。
(2)调试跟踪CreateProcess函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。
3. 实验类型
验证性实验
4. 实验内容
二、实验环境
EOS操作系统
三、实验过程
1. 设计思路和流程图
2. 算法实现
3. 需要解决的问题及解答
(1)在源代码文件NewTwoProc.c提供的源代码基础上进行修改，要求使用hello.exe同时创建10个进程。提示：可以使用PROCESS_INFORMATION类型定义一个有10个元素的数组，每一个元素对应一个进程。使用一个循环创建10个子进程，然后再使用一个循环等待10个子进程结束，得到退出码后关闭句柄。
答：后文中，有此题解决方案。
(2)尝试根据之前对PsCreateProcess函数和PspCreateProcessEnvironment函数执行过程的跟踪调试，绘制一幅进程创建过程的流程图。
(3)在PsCreateProcess函数中调用了PspCreateProcessEnvironment函数后又先后调用了PspLoadProcessImage和PspCreateThread函数，学习这些函数的主要功能。能够交换这些函数被调用的顺序吗？思考其中的原因。
答：PspCreateProcessEnvironment的主要功能是创建进程控制块?并且为进程创建了地址空间和分配了句柄表。PspLoadProcessImage是将进程的可执行映像加载到了进程的地址空间中。PspCreateThread创建了进程的主线程。这三个函数被调用的顺序是不能够改变的?就向上面描述的?加载可执行映像之前必须已经为进程创建了地址空间?这样才能够确定可执行映像可以被加载到内存的什么位置?在创建主线程之前必须已经加载了可执行映像?这样主线程才能够知道自己要从哪里开始执行，执行哪些指令。因此不能交换他们的顺序。
4. 主要数据结构、实现代码及其说明
主要使用PROCESS_INFORMATION类型定义一个有10个元素的数组，每一个元素对应一个进程。使用一个循环创建10个子进程，然后再使用一个循环等待10个子进程结束，得到退出码后关闭句柄。
5. 源程序并附上注释
使用hello.exe同时创建10个进程的原代码及注释如下：
#include "EOSApp.h"
// main 函数参数的意义：
// argc - argv 数组的长度，大小至少为 1，argc - 1 为命令行参数的数量。
//argv-字符串指针数组，数组长度为命令行参数个数+1。其中 argv[0] 固定指向当前
// 进程所执行的可执行文件的路径字符串，argv[1] 及其后面的指针指向各个命令行
// 参数。
// 例如通过命令行内容 "a:\hello.exe -a -b" 启动进程后，hello.exe 的 main 函
// 数的参数 argc 的值为 3，argv[0] 指向字符串 "a:\hello.exe"，argv[1] 指向
// 参数字符串 "-a"，argv[2] 指向参数字符串 "-b"。
int main(int argc, char* argv[])
{
// 启动调试 EOS 应用程序前要特别注意下面的问题：
// 1、如果要在调试应用程序时能够调试进入内核并显示对应的源码，
// 必须使用 EOS 核心项目编译生成完全版本的 SDK 文件夹，然
// 后使用此文件夹覆盖应用程序项目中的 SDK 文件夹，并且 EOS
// 核心项目在磁盘上的位置不能改变。
// 2、在启动调试应用程序之前必须首先删除/禁用所有的断点，在断
// 点中断 (int 3) 被命中后才能重新添加/启用断点，否则启动
// 调试会失败。
STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcInfo[10];
ULONG ulExitCode; // 子进程退出码
INT nResult = 0; // main 函数返回值。0 表示成功，非 0 表示失败。
int i,j;
//#ifdef _DEBUG
// __asm("int $3\n nop");
//#endif
printf("Create 10 processes and wait for the processes exit...\n\n");
// 使子进程和父进程使用相同的标准句柄。
StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);
StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);
// 为一个应用程序同时创建10个子进程。
for(i =0; i < 10; i++)
if(CreateProcess("A:\\Hello.exe", NULL, 0, &StartupInfo, &ProcInfo[i]));
else {
for(j = 0; j < i; j++){
WaitForSingleObject(ProcInfo[j].ProcessHandle, INFINITE);
// 得到并输出子进程的退出码。
GetExitCodeProcess(ProcInfo[j].ProcessHandle, &ulExitCode);
printf("\nThe process %d exit with %d.\n",j,ulExitCode);
// 关闭不再使用的句柄。
CloseHandle(ProcInfo[j].ProcessHandle);
CloseHandle(ProcInfo[j].ThreadHandle);
}
printf("CreateProcess Failed, Error code: 0x%X.\n", GetLastError());
nResult = 1;
return nResult;
}
for(i = 0; i < 10; i++){
// 创建子进程成功，等待子进程运行结束。
WaitForSingleObject(ProcInfo[i].ProcessHandle, INFINITE);
// 得到并输出子进程的退出码。
GetExitCodeProcess(ProcInfo[i].ProcessHandle, &ulExitCode);
}
for( i =0 ; i < 10; i++){
printf("\nThe process %d exit with %d.\n",i,ulExitCode);
// 关闭不再使用的句柄。
CloseHandle(ProcInfo[i].ProcessHandle);
CloseHandle(ProcInfo[i].ThreadHandle);
}
return nResult;
}
6. 程序运行时的初值和运行结果
a.使用控制台命令创建EOS应用程序进程
b.查看应用程序创建另一个应用程序的进程的执行结果:
c.调试进程控制块的创建过程
将鼠标移动到“监视”窗口中此表达式的“值”属性上，会弹出一个临时窗口，在临时窗口中会按照进程控制块的结构显示各个成员变量的值（可以参考PROCESS结构体的定义）。由于只是新建了进程控制块，还没有初始化其中成员变量，所以值都为0。
d.接下来调试初始化进程控制块中各个成员变量的过程:
1.创建进程的地址空间，即4G虚拟地址空间。在代码行（create.c文件的第437行） NewProcess->Pas = MmCreateProcessAddressSpace(); 添加一个断点。
2.按F5继续调试，到此断点处中断。
3.按F10执行此行代码后中断。
4.在“监视”窗口中查看进程控制块的成员变量Pas的值已经不再是0。说明已经初始化了进程的4G虚拟地址空间。
使用F10一步步调试PspCreateProcessEnvironment函数中后面的代码，在调试的过程中根据执行的源代码，查看“监视”窗口中*NewProcess表达式的值结果如下：
e.要求使用hello.exe同时创建10个进程
四、实验体会
本实验主要的问题就是用hello.exe同时创建10个进程：因为编程基础不好，刚开始的程序很难通过编译.最后使用PROCESS_INFORMATION类型定义一个有10个元素的数组，每一个元素对应一个进程。使用一个循环创建10个子进程，然后再使用一个循环等待10个子进程结束，得到退出码后关闭句柄。并对细节做了部分修正才成功。
第二篇：进程的同步实验报告
操作系统
实验报告
哈尔滨工程大学
计算机科学与技术学院
一、实验概述
1. 实验名称
进程的同步
2. 实验目的
⑴使用EOS的信号量，编程解决生产者?消费者问题，理解进程同步的意义。
⑵调试跟踪EOS信号量的工作过程，理解进程同步的原理。
⑶修改EOS的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理。
3. 实验类型
验证+设计
4. 实验内容
⑴准备实验
⑵使用EOS的信号量解决生产者－消费者问题
⑶调试EOS信号量的工作过程
①创建信号量
②等待释放信号量
③等待信号量（不阻塞）
④释放信号量（不唤醒）
⑤等待信号量（阻塞）
⑥释放信号量（唤醒）
⑷修改EOS的信号量算法
二、实验环境
WindowsXP + EOS集成实验环境
三、实验过程
1. 设计思路和流程图
图4-1.整体试验流程图
图4-2.Main函数流程图、生产者消费、消费者流程图
2. 算法实现
3. 需要解决的问题及解答
(1). 思考在ps/semaphore.c文件内的PsWaitForSemaphore和PsReleaseSemaphore函数中，为什么要使用原子操作？
答：在执行等待信号量和释放信号量的时候，是不允许cpu响应外部中断的，如果此时cpu响应了外部中断，会产生不可预料的结果，无法正常完成原子操作。
(2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。
(3).P143生产者在生产了13号产品后本来要继续生产14号产品，可此时生产者为什么必须等待消费者消费了4号产品后，才能生产14号产品呢？生产者和消费者是怎样使用同步对象来实现该同步过程的呢？
答：这是因为临界资源的限制。临界资源就像产品仓库，只有“产品仓库”空闲生产者才能生产东西，有权向里面放东西。所以它必须等到消费者，取走产品，“产品空间”（临界资源）空闲时，才继续生产14号产品。
(4). 根据本实验3.3.2节中设置断点和调试的方法，自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞，直到生产者线程生产了24号产品后，消费者线程才被唤醒并继续执行的过程。
答：可以按照下面的步骤进行调试
(1) 删除所有的断点。
(2) 按F5启动调试。OS Lab会首先弹出一个调试异常对话框。
(3) 在调试异常对话框中选择“是”，调试会中断。
(4) 在Consumer函数中等待Full信号量的代码行（第173行） WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。
(5) 在“断点”窗口（按Alt+F9打开）中此断点的名称上点击右键。
(6) 在弹出的快捷菜单中选择“条件”。
(7) 在“断点条件”对话框（按F1获得帮助）的表达式编辑框中，输入表达式“i == 24”。
(8) 点击“断点条件”对话框中的“确定”按钮。
(9) 按F5继续调试。只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。
4. 主要数据结构、实现代码及其说明
修改PsWaitForSemaphore函数
if (Semaphore->Count>0){
Semaphore->Count--;
flag=STATUS_SUCCESS;
}//如果信号量大于零，说明尚有资源，可以为线程分配
else
flag=PspWait(&Semaphore->WaitListHead, Milliseconds);
KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。
return flag;
}//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待
修改PsReleaseSemaphore函数
if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {
Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;
} else {
// 记录当前的信号量的值。
if (NULL != PreviousCount) {
*PreviousCount = Semaphore->Count;
}
int mm=Semaphore->Count;
// 目前仅实现了标准记录型信号量，每执行一次信号量的释放操作
// 只能使信号量的值增加 1。
while ((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){
PspWakeThread(&Semaphore->WaitListHead, STATUS_SUCCESS);
PspThreadSchedule();
ReleaseCount--;
}
Semaphore->Count=mm+ReleaseCount;
// 可能有线程被唤醒，执行线程调度。
Status = STATUS_SUCCESS;
}
5. 源程序并附上注释
#include "psp.h"
VOID
PsInitializeSemaphore(
IN PSEMAPHORE Semaphore,
IN LONG InitialCount,
IN LONG MaximumCount)
/*++
功能描述：
初始化信号量结构体。
参数：
Semaphore -- 要初始化的信号量结构体指针。
InitialCount -- 信号量的初始值，不能小于 0 且不能大于 MaximumCount。
MaximumCount -- 信号量的最大值，必须大于 0。
返回值：无。
--*/
{
ASSERT(InitialCount >= 0 && InitialCount <= MaximumCount && MaximumCount > 0);
Semaphore->Count = InitialCount;
Semaphore->MaximumCount = MaximumCount;
ListInitializeHead(&Semaphore->WaitListHead);
}
STATUS
PsWaitForSemaphore(
IN PSEMAPHORE Semaphore,
IN ULONG Milliseconds)
/*++
功能描述：
信号量的 Wait 操作（P 操作）。
参数：
Semaphore -- Wait 操作的信号量对象。
Milliseconds -- 等待超时上限，单位毫秒。
返回值：
STATUS_SUCCESS。
当你修改信号量使之支持超时唤醒功能后，如果等待超时，应该返回 STATUS_TIMEOUT。
--*/
{
BOOL IntState;
STATUS flag;
ASSERT(KeGetIntNesting() == 0); // 中断环境下不能调用此函数。
IntState = KeEnableInterrupts(FALSE); // 开始原子操作，禁止中断。
// 目前仅实现了标准记录型信号量，不支持超时唤醒功能，所以 PspWait 函数
// 的第二个参数的值只能是 INFINITE。
if (Semaphore->Count>0){
Semaphore->Count--;
flag=STATUS_SUCCESS;
}
else
flag=PspWait(&Semaphore->WaitListHead, Milliseconds);
KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。
return flag;
}
STATUS
PsReleaseSemaphore(
IN PSEMAPHORE Semaphore,
IN LONG ReleaseCount,
OUT PLONG PreviousCount
)
/*++
功能描述：
信号量的 Signal 操作（V 操作）。
参数：
Semaphore -- Wait 操作的信号量对象。
ReleaseCount -- 信号量计数增加的数量。当前只能为 1。当你修改信号量使之支持
超时唤醒功能后，此参数的值能够大于等于 1。
PreviousCount -- 返回信号量计数在增加之前的值。
返回值：
如果成功释放信号量，返回 STATUS_SUCCESS。
--*/
{
STATUS Status;
BOOL IntState;
IntState = KeEnableInterrupts(FALSE); // 开始原子操作，禁止中断。
if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {
Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;
} else {
// 记录当前的信号量的值。
if (NULL != PreviousCount) {
*PreviousCount = Semaphore->Count;
}
int mm=Semaphore->Count;
// 目前仅实现了标准记录型信号量，每执行一次信号量的释放操作
// 只能使信号量的值增加 1。
while ((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){
PspWakeThread(&Semaphore->WaitListHead, STATUS_SUCCESS);
PspThreadSchedule();
ReleaseCount--;
}
Semaphore->Count=mm+ReleaseCount;
// 可能有线程被唤醒，执行线程调度。
Status = STATUS_SUCCESS;
}
KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。
return Status;
}
//////////////////////////////////////////////////////////////////////////
// 下面是和信号量对象类型相关的代码。
// 信号量对象类型指针。
POBJECT_TYPE PspSemaphoreType = NULL;
// 用于初始化 semaphore 结构体的参数结构体。
typedef struct _SEM_CREATE_PARAM{
LONG InitialCount;
LONG MaximumCount;
}SEM_CREATE_PARAM, *PSEM_CREATE_PARAM;
// semaphore 对象的构造函数，在创建新 semaphore 对象时被调用。
VOID
PspOnCreateSemaphoreObject(
IN PVOID SemaphoreObject,
IN ULONG_PTR CreateParam)
{
PsInitializeSemaphore( (PSEMAPHORE)SemaphoreObject,
((PSEM_CREATE_PARAM)CreateParam)->InitialCount,
((PSEM_CREATE_PARAM)CreateParam)->MaximumCount );
}
// semaphore 对象类型的初始化函数。
VOID
PspCreateSemaphoreObjectType(
VOID)
{
STATUS Status;
OBJECT_TYPE_INITIALIZER Initializer;
Initializer.Create = PspOnCreateSemaphoreObject;
Initializer.Delete = NULL;
Initializer.Wait = (OB_WAIT_METHOD)PsWaitForSemaphore;
Initializer.Read = NULL;
Initializer.Write = NULL;
Status = ObCreateObjectType("SEMAPHORE", &Initializer, &PspSemaphoreType);
if (!EOS_SUCCESS(Status)) {
KeBugCheck("Failed to create semaphore object type!");
}
}
// semaphore 对象的构造函数。
STATUS
PsCreateSemaphoreObject(
IN LONG InitialCount,
IN LONG MaximumCount,
IN PSTR Name,
OUT PHANDLE SemaphoreHandle
)
{
STATUS Status;
PVOID SemaphoreObject;
SEM_CREATE_PARAM CreateParam;
if(InitialCount < 0 || MaximumCount <= 0 || InitialCount > MaximumCount){
return STATUS_INVALID_PARAMETER;
}
// 创建信号量对象。
CreateParam.InitialCount = InitialCount;
CreateParam.MaximumCount = MaximumCount;
Status = ObCreateObject( PspSemaphoreType,
Name,
sizeof(SEMAPHORE),
(ULONG_PTR)&CreateParam,
&SemaphoreObject);
if (!EOS_SUCCESS(Status)) {
return Status;
}
Status = ObCreateHandle(SemaphoreObject, SemaphoreHandle);
if (!EOS_SUCCESS(Status)) {
ObDerefObject(SemaphoreObject);
}
return Status;
}
// semaphore 对象的 signal 操作函数。
STATUS
PsReleaseSemaphoreObject(
IN HANDLE Handle,
IN LONG ReleaseCount,
IN PLONG PreviousCount)
{
STATUS Status;
PSEMAPHORE Semaphore;
if (ReleaseCount < 1) {
return STATUS_INVALID_PARAMETER;
}
// 由 semaphore 句柄得到 semaphore 对象的指针。
Status = ObRefObjectByHandle(Handle, PspSemaphoreType, (PVOID*)&Semaphore);
if (EOS_SUCCESS(Status)) {
Status = PsReleaseSemaphore(Semaphore, ReleaseCount, PreviousCount);
ObDerefObject(Semaphore);
}
return Status;
}
6. 程序运行时的初值和运行结果
四、实验体会
经过本次实验，初步了解操作系统的进程同步的过程。我对生产者-消费者问题的解决办法有了更全面的认识，同时对调试代码更加熟练。本次实验最大的体会就是，做东西要细心，在写代码的过程中，稍不留意就给后期调试工作带来很多问题。