linux操作系统实验报告

一、设计题目
进程管理及理解和增加Linux系统调用

二、设计时间和地点
设计时间:20##年12月26日——20##年12月29日
设计地点:装备制造学院B座502机房

三、设计目的和要求

(1)加深对进程概念的理解,明确进程和程序的区别。

(2)进一步认识并发执行的实质。

(3)分析进程争用资源的现象,学习解决互斥的方法。

(4)了解Linux系统中进程通信的基本原理。

(5)弄清进程管理在操作系统中的地位和作用。

(6) 初步揭开Linux内核的神秘“面纱”,为今后深入学习内核原理打下基础。

(7)弄清系统调用原理,以及操作系统在处理每个系统调用的时候,用户态怎样切入核心态?又怎样从核心态返回到用户态的?

四、设计内容

(1)实验准备

a. 基本头文件
<sys/types.h>:类型头文件,定义了基本的系统数据类型。

<unistd.h>:定义了各种符号常数和类型,并声明了各种函数。

<stdio .h>带缓冲的标准输入输出!

<stdlib.h>头文件即standard library标准库头文件

b.vi编辑器的基本使用

  [root@localhost ~]# vi filename

Command 模式是vi默认模式,如果我们处于其它命令模式时,当我们按ESC键后,接着再输入:号时,vi会在屏幕的最下方等待我们输入命令;

:w 保存;

:w filename 另存为filename;

:wq! 保存退出;

:wq! filename 注:以filename为文件名保存后退出;

:q! 不保存退出;

     c.gcc的基本使用

       1、直接编译

           gcc filename.c -o filename

       2、分步编译

           进行预编译

           # gcc -E hello.c -o hello.i
           生成目标代码

# gcc -c hello.i -o hello.o

链接成可执行文件

# gcc hello.o -o hello

     d.U盘的挂载与卸载

先要为外挂点新建一个子目录,一般外挂点的子目录都是建立在/mnt里面的,也建在那里,当然也可以建在/目录下,名字可以自己定,就取名为usb,终端下的命令如下:mkdir /mnt/usb

       然后接上U盘了,在终端下输入mount /dev/sdb1 /mnt/usb命令并击Enter

删除挂起点,方法是:umount /dev/sdb1 /mnt/usb 或 umount /dev/sdb1

(2)设计内容

1、进程的创建

编写一段程序,使用系统调用fork()创建两个子进程。当此程序运行时,在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符:父进程显示“A”;子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果,并分析原因。

a、程序代码:
#include<stdio.h>

#include<stdlib.h>

#include<sys/types.h>

#include<unistd.h>

main()

{

if(fork()==0)

{

printf("进程b  该进程的ID号为:%d\n",getpid());

exit(0);

}

else

{

if(fork()==0)

{

printf("进程c 该进程的ID号为:%d\n",getpid());

exit(0);

}

printf("进程a   该进程的ID号为:%d\n",getpid());

exit(0);

}

}

b、程序解释

fork()函数:

功能:创建一个新进程。

格式:int fork()

返回值:

·0:创建子进程,从子进程返回的id值

·大于0:从父进程返回的了进程id值

   ·-1:创建失败

   getpid()函数:getpid函数用来取得目前进程的进程识别码,许多程序利用取到                        的此值来建立临时文件

c、结果截图

c、结果分析

       多次运行程序,显示结果不一定唯一。具体显示顺序由调度机制决定。

       2、进程的控制

修改已编写的程序,将每个进程输出一个字符改为每个进程输出一句话,再观察           程序执行时屏幕上出现的现象,并分析原因。

如果在程序中使用系统调用lockf(),来给每一个进程加锁,可以实现进程之间                 的互斥,观察并分析出现的现象。  

a、     程序代码

#include<stdio.h>

#include<signal.h>

#include<unistd.h>

#include<stdlib.h>

main()

{

int p1,p2,i;

if(p1=fork()){

lockf(1,1,0);

printf("子进程2已创建!!\n");

exit(0);

}

else{

if(p2=fork())

printf("子进程1已创建!!\n");

exit(0);

else

printf("父进程已经创建!!\n");

exit(0);

}

}

b、结果截图

c、 结果分析

成功显示一段话,其中循序与进程的调度机制有关

加入lockf()函数后

#include<stdio.h>

#include<signal.h>

#include<unistd.h>

#include<stdlib.h>

main()

{

int p1,p2,i;

if(p1=fork()){

lockf(1,1,0);

printf("子进程2已创建!!\n");

exit(0);

lockf(1,0,0);

}

else{

if(p2=fork())

 lockf(1,1,0); 

printf("子进程1已创建!!\n");

exit(0);

lockf(1,0,0);

else

 lockf(1,1,0); 

printf("父进程已经创建!!\n");

exit(0);

lockf(1,0,0);

}

}

b、程序解释

        lockf()函数:允许将文件区域用作信号量,或用于控制对锁定进程的访问(强制模式记录锁定)。试图访问已锁定资源的其他进程将返回错误或进入休眠状态,直到资源解除锁定为止。当关闭文件时,将释放进程的所有锁定,即使进程仍然有打开的文件。当进程终止时,将释放进程保留的所有锁定。

c、结果分析

        显示结果与未加lockf()并无太大区别,只是显示固定

3、①编制一段程序,使其实现进程的软中断通信。

要求:使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号;当捕捉到中断信号后,父进程用系统调用kill()向两个子进程发出信号,子进程捕捉到信号后分别输出下列信息后终止:

Child  Process11 is  Killed  by  Parent!

Child  Process12 is  Killed  by  Parent!

父进程等待两个子进程终止后,输出如下的信息后终止:

Parent  Process  is  Killed!

a、 程序框图

b、程序代码:

#include<stdio.h>

#include<signal.h>

#include<unistd.h>

#include<stdlib.h>

void waiting(),stop();

int wait_mark;

main()

{

int p1,p2;

if(p1=fork()){

if(p2=fork())   {

wait_mark=1;

signal(SIGINT,stop);  

waiting();

kill(p1,16);          

kill(p2,17);       

wait(0);           

wait(0);

printf("parent process is killed!\n");

exit(0);

}

else{

wait_mark=1;

signal(SIGINT,stop);

waiting();

lockf(1,0,0);

printf("child process2  is killed by parent!\n");

lockf(1,0,0);

exit(0);

}

}

else{

wait_mark=1;

signal(SIGINT,stop);

waiting();

lockf(1,0,0);

printf("child process1 is killed by parent!\n");

lockf(1,0,0);

exit(0);

}

}

void waiting()

{

while (wait_mark!=0);

}

void stop()

{

wait_mark=0;

}

c、    程序解释:

    kill(p1,16):用来送参数16(代表用户自定义信号一)指定的信号给参数p1指定的进程           

kill(p2,17):用来送参数17(代表用户自定义信号二)指定的信号给参数p2指定的进程

signal(SIGINT,stop):捕捉SIGINT信号(ctrl+c会产生该信号),转而执行stop函数

d、   结果截图

      

e、  结果分析:

    由于stop函数与waiting函数共同作用。保证了Parent  Process  is  Killed!一定在Child  Process11 is  Killed  by  Parent!Child  Process12 is  Killed  by  Parent!之后输出。

f、  调试问题:

由于网上原版的程序代码没有<stdlib.h>头文件。而exit(0);是包含在该头文件中,所以会出现“隐式声明与内建函数 ‘exit’ 不兼容”错误。

 

②在上面的程序中增加系统调用signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN),观察执行结果,并分析原因。

a、程序代码:

#include<stdio.h>

#include<signal.h>

#include<unistd.h>

#include<stdlib.h>

int pid1,pid2;

int EndFlag=0;

int pf1=0;

int pf2=0;

void IntDelete()

{

kill(pid1,16);

kill(pid2,17);

EndFlag=1;

}

void Int1()

{

printf("child process 1 is killed !by parent\n");

exit(0);

}

void Int2()

{

printf("child process 2 is killed !by parent\n");

exit(0);

}

main()

{

int exitpid;

signal(SIGINT,SIG_IGN);

signal(SIGQUIT,SIG_IGN);

if(pid1=fork())

{

signal(SIGUSR1,Int1);

signal(SIGINT,SIG_IGN);

pause();

exit(0);

}

else

{

if(pid2=fork())

{

signal(SIGUSR1,Int1);

signal(SIGINT,SIG_IGN);

pause();

exit(0);

}

else{

signal(SIGINT,IntDelete);

waitpid(-1,&exitpid,0);

printf("parent process is killed\n");

exit(0);

}

}

}

b、程序解释:

signal(SIGINT,SIG_IGN):捕捉中断信号,用SIG_IGN忽略

pause():暂停程序,知道signal发出信号

c、结果分析:

由于忽略了中断与退出信号,程序会一直保持阻塞状态而无法退出

4、进程的管道通信

编制一段程序,实现进程的管道通信,

使用系统调用pipe()建立一个管道文件;两个子进程P1和P2分别向管道各写一句话:

Child1  is  sending  a  message!

Child2  is  sending  a  message!

而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。

要求父进程先接收子进程P1发来的消息,然后再接收子进程P2发来的消息。

a、 程序框图

b、 程序代码:

#include<unistd.h>

#include<signal.h>

#include<stdlib.h>

#include<stdio.h>

int pid1,pid2;

main()

{

int fd[2];

char OutPipe[100],InPipe[100];

pipe(fd);

while((pid1=fork())==-1);

if(pid1==0)

{

lockf(fd[1],1,0);

sprintf(OutPipe,"child 1 process is sending message!"); write(fd[1],OutPipe,50);

sleep(5);

lockf(fd[1],0,0);

exit(0);

}

else

{

while((pid2=fork())==-1);

if(pid2==0)

{

lockf(fd[1],1,0);

sprintf(OutPipe,"child 2 proeess is sending message!");

write(fd[1],OutPipe,50);

sleep(5);

lockf(fd[1],0,0);

exit(0);

}

else

{

wait(0);

read(fd[0],InPipe,50);

printf("%s\n",InPipe);

wait(0);

read(fd[0],InPipe,50);

printf("%s\n",InPipe);

exit(0);

}

}

}

c、程序解释:

read(fd[0],InPipe,50); 参数handle所指的文件传送nbyte个字节到buf指针所指的内存中。

write(fd[1],OutPipe,50);//fd[1]文件描述符(写),buffer,50个字节

sprintf(OutPipe,"child 1 process is sending message!");//将引号内容输入到OutPipe数组中

sleep(5):让程序睡眠5秒

pipe(fd):通道函数,参数确定读写操作

d、结果截图:

e、结果分析

管道两端可分别用描述字fd[0]以及fd[1]来描述,需要注意的是,管道的两端是固定了任务的。即一端只能用于读,由描述字fd[0]表示,称其为管道读端;另一端则只能用于写,由描述字fd[1]来表示,称其为管道写端。

(三)、自学笔记:

           程序段中每个进程退出时都用了语句exit(0),为什么?请读者思考。

这是进城的正常终止。在正常终止时exit()函数会返回进程结束状态。异常终止时,则由系统内核产生一个代表异常终止原因的终止状态。该进程的父进程都能用wait()得到其终止状态。在子进程调用exit()后,子进程的结束状态会返回给系统内核,由内核根据状态字生成的终止状态。供父进程在wait()中读取数据,若子进程结束后,父进程还没有读取子进程的终止状态,则系统就子进程的终止状态设置为“ZOMBIE”并保留子进程的控制块信息。父进程读取信息后,系统才彻底释放子进程的控制块。若父进程在子进程结束之前结束的话,则子进程就编程了“孤儿进程”,系统进程init会自动“收养”该子进程,成为该子进程的父进程即父进程标识号变为1,当子进程结束时,init会自动调用wait()读取子进程的遗留数据,从而避免在系统中留下的大量垃圾。

信号标识表

参考书目

《Linux的内核与编程》 机械工业出版社 雷澎等

《Linux的安装与使用》 机械工业出版社 雷澎等

《操作系统课程设计》  机械工业出版社 罗宇等

有关Linux的相关书籍

(四)、设计体会:

        linux系统不同于windows系统,图形界面功能不是很强大,但是它的运行速度及响应时间快于windows,而且性能稳定。本次试验,初步接触了linux系统。对其命令行的操作方式初步了解。深刻感触到我现在对鼠标的依赖。比如U盘的加载与卸载,以前windows系统下只是点一点鼠标就能解决。可是linux系统下需要自己敲命令代码,否则寸步难行。对于命令行方式的了解相信会给我将来学习铺好路,因为以后接触的东西一定会那些没有现成结果的,需要自己动手创建的。关于程序方面,虽然多数是从网上拷贝的,因为对于linux的系统调用我并不熟悉,比如fork()函数我就从来没有见过。还有linux下c语言的头文件都不是很清楚。但是这次的实验并没有仅仅的拷贝粘贴。我细心的分析了网上的程序,每个不懂得函数都仔细的查询了其功能及参数。让我对linux的系统调用有了初步认识。也初步接触了linux系统下编程过程。此外,我还附加的了解了vi编辑器的基本使用。现已经成使用vi编辑器编辑c语言函数。也今本掌握了gcc编译器的编译过程。不过同时也存在一些问题。比如,我还是不能熟练的应用linux系统调用,还不能靠自己的能力写出实验内容程序。总之,本次试验我受益匪浅,拓展了不同的操作系统方面的知识。相信这只是起步,将来我会在这个基础上进一步发展。

相关推荐