Linux 进程管理实验
进程管理演示实验报告
一、实验目的1. 理解进程的概念及其在操作系统中的作用。
2. 掌握Linux系统中进程的创建、调度、同步和通信方法。
3. 熟悉进程的阻塞、挂起、恢复和终止操作。
4. 学习使用相关命令和工具进行进程管理和调试。
二、实验环境操作系统：Linux开发环境：GCC、Xshell三、实验内容1. 进程创建与调度2. 进程同步与通信3. 进程阻塞与恢复4. 进程终止与调试四、实验步骤1. 进程创建与调度（1）编写一个简单的C程序，使用fork()函数创建一个子进程。
（2）在父进程中，使用getpid()和getppid()函数获取进程ID和父进程ID。
（3）使用ps命令查看当前系统中的进程，观察父进程和子进程的状态。
（4）使用waitpid()函数等待子进程结束。
2. 进程同步与通信（1）编写一个使用管道（pipe）进行进程间通信的C程序。
（2）父进程向管道中写入数据，子进程从管道中读取数据。
（3）使用ps命令查看进程状态，观察管道通信的效果。
（4）编写一个使用信号量（semaphore）进行进程同步的C程序。
（5）使用sem_wait()和sem_post()函数实现进程同步。
3. 进程阻塞与恢复（1）编写一个使用sleep()函数使进程阻塞的C程序。
（2）在父进程中，使用waitpid()函数等待阻塞的子进程结束。
（3）使用kill()函数向阻塞的进程发送SIGCONT信号，使其恢复执行。
4. 进程终止与调试（1）编写一个使用exit()函数终止进程的C程序。
（2）在父进程中，使用waitpid()函数等待终止的子进程。
（3）使用gdb调试器分析程序运行过程中出现的问题。
五、实验结果与分析1. 进程创建与调度实验结果表明，使用fork()函数成功创建了子进程，父进程和子进程的进程ID和父进程ID被正确获取。
通过ps命令，可以观察到父进程和子进程的状态。
2. 进程同步与通信实验结果表明，管道通信可以成功实现父进程和子进程之间的数据传递。
进程管理实验报告源代码(3篇)
第1篇---进程管理实验报告一、实验目的1. 理解进程的概念和进程管理的基本原理。
2. 掌握进程的创建、调度、同步和通信等操作。
3. 通过编程实现简单的进程管理功能。
二、实验环境1. 操作系统：Windows/Linux2. 编程语言：C/C++3. 开发环境：Visual Studio/Code::Blocks三、实验内容1. 进程的创建与终止2. 进程的同步与互斥3. 进程的通信4. 进程调度算法四、实验步骤1. 进程的创建与终止```cinclude <stdio.h>include <sys/types.h>include <unistd.h>int main() {pid_t pid;// 创建子进程pid = fork();if (pid < 0) {// 创建进程失败perror("fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process, PID: %d\n", getpid()); // 执行子进程的任务...sleep(5); // 子进程暂停5秒_exit(0); // 子进程退出} else {// 父进程printf("Parent process, PID: %d\n", getpid()); wait(NULL); // 等待子进程结束printf("Child process has terminated.\n");}return 0;}```2. 进程的同步与互斥```cinclude <stdio.h>include <pthread.h>pthread_mutex_t mutex;void thread_func(void arg) {pthread_mutex_lock(&mutex); // 加锁printf("Thread %ld is running\n", (long)arg);sleep(1); // 模拟任务执行pthread_mutex_unlock(&mutex); // 解锁return NULL;}int main() {pthread_t thread1, thread2;// 初始化互斥锁pthread_mutex_init(&mutex, NULL);// 创建线程pthread_create(&thread1, NULL, thread_func, (void )1); pthread_create(&thread2, NULL, thread_func, (void )2); // 等待线程结束pthread_join(thread1, NULL);pthread_join(thread2, NULL);// 销毁互斥锁pthread_mutex_destroy(&mutex);return 0;}```3. 进程的通信```cinclude <stdio.h>include <stdlib.h>include <sys/ipc.h>include <sys/shm.h>int main() {key_t key;int shmid;int data;// 生成共享内存标识符key = ftok("shmfile", 65);// 创建共享内存段shmid = shmget(key, sizeof(int), 0666 | IPC_CREAT); if (shmid == -1) {perror("shmget failed");exit(1);}// 连接到共享内存段data = (int )shmat(shmid, (void )0, 0);if (data == (int )(-1)) {perror("shmat failed");exit(1);}// 使用共享内存data = 100;printf("Data in shared memory: %d\n", data); // 分离共享内存段if (shmdt(data) == -1) {perror("shmdt failed");exit(1);}// 删除共享内存段if (shmctl(shmid, IPC_RMID, NULL) == -1) { perror("shmctl failed");exit(1);}return 0;}```4. 进程调度算法```cinclude <stdio.h>include <stdlib.h>include <sys/time.h>typedef struct {int pid;int arrival_time;int burst_time;int waiting_time;int turnaround_time;} Process;int main() {Process processes[] = {{1, 0, 5, 0, 0},{2, 1, 3, 0, 0},{3, 4, 8, 0, 0}};int n = sizeof(processes) / sizeof(processes[0]);// 计算等待时间和周转时间int total_waiting_time = 0, total_turnaround_time = 0;for (int i = 0; i < n; i++) {if (i == 0) {processes[i].waiting_time = 0;} else {processes[i].waiting_time = processes[i - 1].turnaround_time;}processes[i].turnaround_time = processes[i].burst_time + processes[i].waiting_time;total_waiting_time += processes[i].waiting_time;total_turnaround_time += processes[i].turnaround_time;}printf("Average Waiting Time: %f\n", (float)total_waiting_time / n);printf("Average Turnaround Time: %f\n", (float)total_turnaround_time / n);return 0;}```五、实验结果与分析（此处应填写实验结果，包括运行程序输出、图表等，以及对实验结果的分析。
Linux 进程管理实验
Linux 进程管理实验一、实验内容：1. 利用bochs观测linux0.11下的PCB进程控制结构。
2。
利用bochs观测linux0.11下的fork。
c源代码文件，简单分析其中的重要函数。
3。
在fork.c适当位置添加代码,以验证fork函数的工作原理。
二、Linux进程管理机制分析Linux有两类进程:一类是普通用户进程，一类是系统进程,它既可以在用户空间运行，又可以通过系统调用进入内核空间，并在内核空间运行；另一类叫做内核进程，这种进程只能在内核空间运行. 在以i386为平台的Linux系统中，进程由进程控制块,系统堆栈,用户堆栈，程序代码及数据段组成。
Linux系统中的每一个用户进程有两个堆栈：一个叫做用户堆栈，它是进程运行在用户空间时使用的堆栈;另一个叫做系统堆栈，它是用户进程运行在系统空间时使用的堆栈。
1.Linux进程的状态：Linux进程用进程控制块的state域记录了进程的当前状态，一个Linux 进程在它的生存期中，可以有下面6种状态。
1。
就绪状态（TASK_RUNNING）：在此状态下，进程已挂入就绪队列，进入准备运行状态.2。
运行状态(TASK_RUNNING）：当进程正在运行时，它的state域中的值不改变。
但是Linux会用一个专门指针（current）指向当前运行的任务。
3。
可中断等待状态（TASK_INTERRUPTIBLE）:进程由于未获得它所申请的资源而处在等待状态。
不管是资源有效或者中断唤醒信号都能使等待的进程脱离等待而进入就绪状态。
即”浅睡眠状态”。
4.不可中断等待状态(TASK_UNINTERRUPTIBLE)：这个等待状态与上面等待状态的区别在于只有当它申请的资源有效时才能被唤醒，而其它信号不能.即“深睡眠状态"。
5.停止状态(TASK_STOPPED)：当进程收到一个SIGSTOP信号后就由运行状态进入停止状态，当收到一个SINCONT信号时,又会恢复运行状态.挂起状态。
linux进程管理的实验报告
实验报告：Linux进程管理1. 引言本实验报告将详细介绍Linux系统中进程管理的相关知识和操作。
进程管理是操作系统中的一个重要组成部分，它负责控制和调度系统中运行的各个进程，确保系统资源的合理分配和进程的正常运行。
在本实验中，我们将通过一系列步骤来了解Linux系统中进程的创建、监控和控制。
2. 实验环境为了完成本实验，我们需要在一台运行Linux操作系统的计算机上进行操作。
本实验报告基于Ubuntu 20.04 LTS操作系统进行撰写，但是适用于大多数Linux 发行版。
3. 实验步骤步骤一：创建新进程在Linux系统中，可以通过fork()系统调用来创建新的进程。
以下是一个简单的示例代码：#include <stdio.h>#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {// 子进程逻辑printf("这是子进程\n");} else if (pid > 0) {// 父进程逻辑printf("这是父进程\n");} else {// 进程创建失败printf("进程创建失败\n");}return0;}步骤二：查看进程信息Linux系统提供了多种命令来查看系统中运行的进程信息。
以下是一些常用的命令：•ps：显示当前终端下的进程列表。
•top：实时显示进程的CPU、内存等资源占用情况。
•pstree：以树状结构显示进程的层次关系。
步骤三：杀死进程有时候我们需要终止一个运行中的进程，可以使用kill命令来发送终止信号给目标进程。
以下是一个示例：kill <PID>请将<PID>替换为目标进程的进程ID。
步骤四：进程优先级调整通过调整进程的优先级，可以影响进程在系统中的调度顺序。
在Linux系统中，可以使用nice命令来调整进程的优先级。
Linux进程管理实验
child_proc_number; } ……
操作系统－实验2
for (i=0; i<child_proc_number; i++) { /* 填写代码，建立child_proc_number个子进程要执行 * proc_number = i; * do_something(); * 父进程把子进程的id保存到pid[i] */
操作系统－实验2
实验2 进程 实验报告 回答下列问题，写入实验报告。 1. 你最初认为运行结果会怎么样？ 2. 实际的结果什么样？有什么特点？试对产生该现 象的原因进行分析。 3. proc_number 这个全局变量在各个子进程里的值 相同吗？为什么？ 4. kill 命令在程序中使用了几次？每次的作用是什么 ？执行后的现象是什么？ 5. 使用kill 命令可以在进程的外部杀死进程。进程怎 样能主动退出？这两种退出方式哪种更好一些？
操作系统－实验2
main(int argc, char* argv[]) {
/* 子进程个数 */ int child_proc_number = MAX_CHILD_NUMBER; int i, ch; pid_t child_pid; pid_t pid[10]={0}; /* 存放每个子进程的id */ if (argc > 1) /* 命令行参数第一个参数表示子进程个数*/ {
操作系统－实验2
void do_something() { for(;;) { printf("This is process No.%d and its pid is %d, proc_number, getpid()); sleep(SLEEP_INTERVAL); /* 主动阻塞两秒钟 */ }
Linux进程管理-实验报告
《Linux 操作系统设计实践》实验一：进程管理实验目的：（1) 加深对进程概念的理解，明确进程和程序的区别。
(2）进一步认识并发执行的实质.（3) 学习通过进程执行新的目标程序的方法。
(4) 了解Linux 系统中进程信号处理的基本原理.实验环境:Red Hat Linux实验内容：(1)进程的创建编写一段程序，使用系统调用fork（）创建两个子进程，当此进程运行时,在系统中有一个父进程和两个子进程活动，让每一个进程在屏幕上显示一个字符，父进程显示字符“a"；子进程分别显示字符“b”和字符“c”，试观察记录屏幕上的显示结果，并分析原因.程序代码:#include<stdio。
h〉int main（）｛int p1 ，p2 ；while（（p1=fork（））==-1)；if（p1==0）putchar（’b'）；else｛while（(p2=fork（））==—1)；if（p2==0）putchar（’c')；elseputchar(’a')；｝return 0；｝运行结果：bca分析:第一个while里调用fork（）函数一次,返回两次。
子进程P1得到的返回值是0,父进程得到的返回值是新子进程的进程ID（正整数)；接下来父进程和子进程P1两个分支运行,判断P1==0,子进程P1符合条件,输出“b”;接下来else里面的while里再调用fork（）函数一次,子进程P2得到的返回值是0，父进程得到的返回值是新子进程的进程ID(正整数）；接下来判断P2==0，子进程P2符合条件,输出“c”,接下来父进程输出“a”，程序结束。
（2)进程的控制①修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，在观察程序执行时屏幕上出现的现象，并分析原因。
程序代码：＃include〈stdio。
h>int main（）｛int p1,p2；while（（p1=fork（））==-1）；if（p1==0）printf("Child1 is running！\n”）;else{while（（p2=fork(））==—1）；if(p2==0)printf（”Child2 is running！\n”）;elseprintf(”Fath er is running！\n”）;｝return 0；｝运行结果:Child1 is running！Child2 is running!Father is running！分析：本实验和上一个实验一样,只是将每个进程输出一个字符改为每个进程输出一句话.第一个while里调用fork（）函数一次，返回两次。
实验五linux进程管理
实验五L i n u x进程管理(总5页)本页仅作为文档封面，使用时可以删除This document is for reference only-rar21year.March实验五 Linux进程管理一.实验目的：1．进行系统进程管理。
2．周期性任务安排二.实验内容：1．进程状态查看；2．控制系统中运行的进程；3．安排一次性和周期性自动执行的后台进程；三.实验练习：任务一进程管理实验内容：1、查看系统中的进程；2、控制系统中的进程；3、安排计划任务。
实验步骤：1.使用ps命令查看和控制进程显示本用户的进程：显示所有用户的进程：。
在后台运行cat命令：查看进程cat ：杀死进程cat：。
再次查看进程cat，看看是否被杀死。
注：ps命令包括较丰富的可选参数，常见的可选参数包括如下几个。
-A：显示所有用户启动的进程。
-a：显示所有其他用户的进程。
-u:：显示进程拥有者、进程启动时间等更详细的信息。
-x：显示不是终端提供的进程信息。
-r：只显示正在运行的进程。
-m：显示线程信息。
-w：宽行显示进程信息。
-l：用长格式显示进程信息。
-t:：只显示由终端/dev/tty提交的信息。
2.使用top命令查看和控制进程用top命令动态显示当前的进程。
只显示用户user01的进程（利用u键）。
利用k键，杀死指定进程号的进程。
top参数：-b 以批量模式运行，但不能接受命令行输入；-c 显示命令行，而不仅仅是命令名；-d N 显示两次刷新时间的间隔，比如 -d 5，表示两次刷新间隔为5秒；-i 禁止显示空闲进程或僵尸进程；-n NUM 显示更新次数，然后退出。
比如 -n 5，表示top更新5次数据就退出；-p PID 仅监视指定进程的ID；PID是一个数值；-q 不经任何延时就刷新；-s 安全模式运行，禁用一些效互指令；-S 累积模式，输出每个进程的总的CPU时间，包括已死的子进程；交互式命令键位：space 立即更新；c 切换到命令名显示，或显示整个命令（包括参数）；f,F 增加显示字段，或删除显示字段；h, 显示有关安全模式及累积模式的帮助信息；k 提示输入要杀死的进程ID，目的是用来杀死该进程（默人信号为15）i 禁止空闲进程和僵尸进程；l 切换到显法负载平均值和正常运行的时间等信息；m 切换到内存信息，并以内存占用大小排序；n 提示显示的进程数，比如输入3，就在整屏上显示3个进程；o,O 改变显示字段的顺序；r 把renice 应用到一个进程，提示输入PID和renice的值；s 改变两次刷新时间间隔，以秒为单位；t 切换到显示进程和CPU状态的信息；A 按进程生命大小进行排序，最新进程显示在最前；M 按内存占用大小排序，由大到小；N 以进程ID大小排序，由大到小；P 按CPU占用情况排序，由大到小S 切换到累积时间模式；T 按时间／累积时间对任务排序；W 把当前的配置写到~/.toprc中；3.挂起和恢复进程执行命令cat。
进程管理实验报告分析(3篇)
第1篇一、实验背景进程管理是操作系统中的一个重要组成部分，它负责管理计算机系统中所有进程的创建、调度、同步、通信和终止等操作。
为了加深对进程管理的理解，我们进行了一系列实验，以下是对实验的分析和总结。
二、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。
2. 进一步认识并发执行的实质。
3. 分析进程争用资源的现象，学习解决进程互斥的方法。
4. 了解Linux系统中进程通信的基本原理。
三、实验内容1. 使用系统调用fork()创建两个子进程，父进程和子进程分别显示不同的字符。
2. 修改程序，使每个进程循环显示一句话。
3. 使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号，实现进程的终止。
4. 分析利用软中断通信实现进程同步的机理。
四、实验结果与分析1. 实验一：父进程和子进程分别显示不同的字符在实验一中，我们使用fork()创建了一个父进程和两个子进程。
在父进程中，我们打印了字符'a'，而在两个子进程中，我们分别打印了字符'b'和字符'c'。
实验结果显示，父进程和子进程的打印顺序是不确定的，这是因为进程的并发执行。
2. 实验二：每个进程循环显示一句话在实验二中，我们修改了程序，使每个进程循环显示一句话。
实验结果显示，父进程和子进程的打印顺序仍然是随机的。
这是因为并发执行的进程可能会同时占用CPU，导致打印顺序的不确定性。
3. 实验三：使用signal()捕捉键盘中断信号，并通过kill()向子进程发送信号在实验三中，我们使用signal()捕捉键盘中断信号（按c键），然后通过kill()向两个子进程发送信号，实现进程的终止。
实验结果显示，当按下c键时，两个子进程被终止，而父进程继续执行。
这表明signal()和kill()在进程控制方面具有重要作用。
4. 实验四：分析利用软中断通信实现进程同步的机理在实验四中，我们分析了利用软中断通信实现进程同步的机理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Linux 进程管理实验
一、实验内容：
1. 利用bochs观测linux0.11下的PCB进程控制结构。
2. 利用bochs观测linux0.11下的fork.c源代码文件，简单分析其中的重要函数。
3. 在fork.c适当位置添加代码，以验证fork函数的工作原理。
二、Linux进程管理机制分析
Linux有两类进程：一类是普通用户进程，一类是系统进程，它既可以在用户空间运行，又可以通过系统调用进入内核空间，并在内核空间运行；另一类叫做内核进程，这种进程只能在内核空间运行。
在以i386为平台的Linux系统中，进程由进程控制块，系统堆栈，用户堆栈，程序代码及数据段组成。
Linux系统中的每一个用户进程有两个堆栈：一个叫做用户堆栈，它是进程运行在用户空间时使用的堆栈；另一个叫做系统堆栈，它是用户进程运行在系统空间时使用的堆栈。
1.Linux进程的状态：
Linux进程用进程控制块的state域记录了进程的当前状态，一个Linux 进程在它的生存期中，可以有下面6种状态。
1.就绪状态(TASK_RUNNING)：在此状态下，进程已挂入就绪队列，进入准备运行状态。
2.运行状态(TASK_RUNNING)：当进程正在运行时，它的state域中的值不改变。
但是Linux会用一个专门指针(current)指向当前运行的
任务。
3.可中断等待状态(TASK_INTERRUPTIBLE)：进程由于未获得它所申请的资源而处在等待状态。
不管是资源有效或者中断唤醒信号都能使等待的进程脱离等待而进入就绪状态。
即”浅睡眠状态”。
4.不可中断等待状态(TASK_UNINTERRUPTIBLE)：这个等待状态与上面等待状态的区别在于只有当它申请的资源有效时才能被唤醒，而其它信号不能。
即“深睡眠状态”。
5.停止状态（TASK_STOPPED)：当进程收到一个SIGSTOP信号后就由运行状态进入停止状态，当收到一个SINCONT信号时，又会恢复运行状态。
挂起状态。
6.终止状态（TASK_ZOMBIE)：进程因某种原因终止运行，但进程控制块尚未注销。
即“僵死状态”。
状态图如下所示：
2.Linux进程控制块：
在Linux中，进程控制块为数据结构task_struct,它包含了大量该进程的信息，这些信息大致为以下几类：
1）.进程的当前状态
2）.调度信息
3）.进程标识
4）.进程的通信信息
5）.进程与其它进程之间关系的信息
6）.使用文件的信息
7）.虚拟内存与物理内存的关系
8）.计时器
9）.处理器与进程的有关信息
3. Fork函数：
父进程创建一个子进程最方便快捷的方式就是把父进程的控制块照原样复制一个，然后再根据子进程的修改特点对它进行必要的修改，形成子进程的控制块。
系统调用fork()通过调用find_empty_process及copy_process 等函数复制一个当前进程的进程控制块，然后用新进程标识修改旧标识，填写子进程与父进程关系，创建子进程堆栈和数据区。
因此，fork()执行后，父子进程共享同一个存储空间，父进程的所有可共享资源都被子进程通过数据结构的复制继承了过来。
在父进程调用fork()与在子进程中调用fork()，fork()的返回值不同！如果是在父进程调用fork()，则fork()就复制出一个子进程，并返回子
进程的标识ID，如果创建子进程失败，则fork()的返回值为-1;而如果在子进程调用fork(),则它返回的是0。
三、实验步骤及结果
在安装目录下双击bochs.exe，选择提供好的linux0.11配置文件，点击start，启动虚拟机，如下图所示：
一、利用bochs观测linux0.11下的PCB进程控制结构
1.切换工作目录到/usr/src/linux/include/linux文件夹，如下所
示：
2.利用vi编辑器打开sched.h头文件，寻找struct task_struct结构体的定义，如下：
观察进程控制块的内容，对里面的一些变量分析：
Long state：表示当前进程所处的状态。
-1为不可运行，0可运行(就绪)，>0 已停止。
进程执行时，它会根据具体情况改变状态。
Linux 中的进程主要有如下状态，如下所示：
Long counter:表示当前进程所剩余的时间片
Long priority:表示当前进程的优先级。
Long signal:存储进程收到的信号。
Unsigned short uid:用户ID,指的是进程执行者是谁。
Struct file* filp[NR_OPEN]:进程打开的文件列表：进程可以打开或关闭文件，文件属于系统资源，Linux内核要对进程使用文件
的情况进行记录。
task_struct结构中有两个数据结构用于描述进程与文件相关的信息。
其中，fs_struct中描述了两个VFS索引节点（VFS inode），这两个索引节点叫做root和pwd，分别指向进程的可执行映象所对应的根目录和当前目录或工作目录。
file_struct结构用来记录了进程打开的文件的描述符。
二、利用bochs观测linux0.11下的fork.c源代码文件，分析其
中的重要函数：
1.切换工作目录到/usr/src/linux/kernel文件夹，利用vi编辑打开fork.c文件：通过观察该程序主要实现了以下几个函数：
find_empty_process,copy_mem,copy_process等，其中，调用关系大体如下所示:
Fork调用find_empty_process，而后者又调用copy_process；然后Copy_process调用copy_mem，Copy_mem调用copy_page_tables，下面找到copy_process函数，如下：
在该函数中有*p=*current代码，这句代码表示：
current是指向父进程PCB结构体的指针，p是指向子进程PCB结构体的指针，操作系统先把父进程的PCB结构体完完整整的复制了一份给子进程。
2.找到copy_mem函数，发现其调用copy_page_tables。
其中，
copy_page_tables的实现在/usr/src/linux/mm/memory.c文件中，其代码截图如下:
上述代码表明把两个进程的不同线性空间映射到同一片物理内存上。
2.当copy_process调用结束后，整个创建进程的过程就已经完成了
大半部分，此后，再对子进程的信息做必要修改后，子进程就可以像父进程一样被执行了。
三、在fork.c适当位置添加代码，以验证fork函数的工作原理
1.fork函数复制了父进程的PCB，这里验证一下具有父子关系的两个
进程，是否一致。
2.打开/usr/src/linux/kernel/fork.c文件，找到其中
copy_process函数如下,在函数的最后，加入相关打印信息代码在程序的后面，并去除注释：
程序中if(p-pid>5&&p->father!=4)是为了区别系统进程与用户进程而设置的。
因为，如果不这样区分，会导致打印出一些我们不想看到的信息，造成混乱，不方便实验观察。
p->start_code是p所指向进程的页目录信息。
exper_page_table是p所指向进程的页表信息。
For(k1=0;k1<NR_TASKS;k1++)循环是在系统的进程槽中找到p所指向进程的父进程，然后，将父进程相关页目录，页表信息打印。
3.保存并退出vi编辑器，切换工作目录到/usr/src/linux执10行. make clean命令，将系统以前的编译信息清除掉。
4.然后执行make命令，重新编译linux0.11内核
5. 编译完成后，输入dd bs=8192 if=Image of=/dev/fd0，用新生成的内核替换掉旧的内核。
6. 点击bochs中中的reset按钮，重启虚拟机；重启后，编译运行experiment.c文件，观察实验效果，其中experiment.c程序代码如下图所示：
编译运行结果显示如下：
由运行结果可以看出，父子进程的页表指向了同一个物理地址，从而验证了我们之前的理论,子进程会复制父进程的PCB，共享其内存空间。
四、实验结果与心得
本次实验主要通过学习Linux系统进程管理机制，并通过Bochs
进行验证。
实验中通过初步阅读linux0.11操作系统源代码，了解其创建进程的大体流程。
另外，通过修改源代码，验证了fork函数的工作原理。
实验中首先要
比较深入的理解进程控制块以及fork函
数，我觉得自己理解起来还是有点困难。
不过通过实验，阅读内核代码的能力有
所提高，并初步学会如何去修改代码并
实现验证。
为以后的学习打下一个良好
的基础，所以收获颇多。