操作系统实验复习题(带答案).doc

操作系统实验复习题
1. 目录操作（要求：写出相应的命令，并把执行过程截图）
l 在/home目录下建立自己的子目录mydir。
mkdir mydir
l 进入/home/mydir，创建多个子目录。
cd mydir
mkdir –p newdir
mkdir –p newdir1
l 查看当前目录下创建的子目录的详细情况。
ls –F /

l 删除部分子目录。
rmdir newdir1
l 查看当前目录下创建的子目录和文件的详细情况。
ls -a
l 回退到上级目录
cd ..

2. 文件操作（要求：写出相应的命令，并把执行过程截图）
l 当前目录下，用文件编辑器gedit创建新的文件file.c 。
gedit file.c
l ls –l 长格式显示目录清单，查看文件权限。
ls-l
l 创建子目录newdir，复制文件file.c到newdir目录。
mkdir –p newdir
cp file.c newdir
l 将file.c改名为myfile.c。
mv file.c myfile.c

3. 编写一段程序，使用系统调用fork()创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一段字符信息。（要求： 把代码、程序编译和运行结果截图）

#include<stdio.h>
main()
{
int p1,p2;
p1=fork();
if(p1==0) {
printf("This is child process 1! pid is %d:\n",getpid());
}
else if(p1>0)
{
printf("This is parent process! pid is %d:\n",getpid());
p2=fork();
if(p2==0){
printf("This is child process 2! pid is %d:\n",getpid());
}
else if(p2>0){
printf("This is parent process! pid is %d:\n",getpid());
}
else{
printf("fork()error!\n"); }
}
else{
printf("fork()error!\n"); }
}

4. 编译并并运行以下程序，利用kill命令对该后台执行程序的，分别执行让它暂停、恢复执行和终止控制方式，期间多次使用ps -l命令查看进程状态。（要求：把程序编译，后台执行，控制执行以及查看进程状态的运行结果截图）
/*loop.c*/
#include <stdio.h>
main()
{
while(1){}
}
5.
/*forktree.c*/
#include <sys/types.h>
/*forktree.c*/
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
main()
{
int p;
p=fork();
printf("fork 1\n");
if (p>0) /*如果是父进程*/
{
fork();
fork();
}
else{ /*如果是子进程*/
fork();
fork();
}
sleep(50);
}
要求：把程序编译，后台执行，利用ps命令查看进程的ID号，以进程的ID号为进程名称，画出程序的运行过程中产生的进程树。

6.
/*fork2.c */
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
main()
{
int p,x;
x=1;
p=fork();
if (p>0)
printf("parent output x=%d\n",++x);
else
printf("child output x=%d\n",++x);
}
要求：写出程序的运行结果，并简要分析fork()系统调用创建子进程后，父进程和子进程之间的关系。

7. 编写程序代码，要求子进程利用execl()函数调用另一个可执行程序的代码。（要求： 把代码、程序编译和运行结果截图）

8. 分析程序执行流程，运行结果以及kill()和signal()的功能。
/*signal1.c*/
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include<stdlib.h>
int i;
void intfun( )
{
i=0;
}
main( )
{
int k,j,pid;
j=1;
while((pid=fork( ))==-1);
if (pid>0)
{
for(k=1;k<3;k++)
{
printf("how are you!\n");
sleep(1);
}
kill(pid,17); /*发送软中断信号给子进程*/
wait(0); /*等待子进程终止*/
printf("Parent exited\n");
exit(0);
}
else
{
signal(17,intfun); /*预置软中断信号17*/
i=1;
while(i==1) /*循环显示并等待父进程发软中断信号*/
{
printf("I am child:%d\n",j++);
sleep(1);
}
printf("Child exited\n");
exit(0);
}
}
9. 编写程序实现父进程和子进程基于无名管道进行通信。用系统调用pipe()建立一无名管道，父进程向管道写入一句话，子进程从无名管道中读出两个来自子进程的信息并显示。
（要求： 把代码、程序编译和运行结果截图）
10. 把下面程序空缺的语句填写完整，通过这个程序分析共享存储区通信机制的优缺点。

#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>
#define SHMKEY 75 //定义符号变量，每个用户取不同的共享内存关键字值
int shmid,i; int *addr; //定义指向整型 变量的指针变量，
main( )
{ while ((i=fork( ))==-1);
if (!i) server( );
system(“ipcs -m”);
while ((i=fork( ))==-1);
if (!i) client( );
wait(0); wait(0);}
void server( )
{ （ 1 ）;

（ 2 ）;
do
{ *addr=-1;
system(“ipcs -m”);
while (*addr==-1);
printf("(server) received:%d\n",*addr);
}while (*addr);
（ 3 ）;;

exit(0);
}
void client( )
{ int i;
（ 4 ）;

（ 5）;
for (i=9;i>=0;i--)
{ while (*addr!=-1);
*addr=i;
printf("(client) sent:%d\n",*addr);
}
exit(0);
}

11. 编写程序利用消息队列通信机制实现两个进程之间的单项通信程序，一个进程发送从键盘接收的数据，另一个进程接收数据并显示。在程序运行期间调用“ipcs –q”查看消息队列的使用情况。 （要求： 把代码、程序编译和运行结果截图）

12. 文件硬链接（要求按照下面的步骤操作，把操作命令、操作流程和结果截图）
（1）创建一个文件a：
（2）创建一个链接：
（3）创建文件a的一个复制版本：
（4）观察3个文件a, b, c的索引节点、权限、属主、大小、时间等属性：
（5）修改文件a中的内容。
（6）使用cat命令分别观察文件b和文件c的内容。
（7）再次观察3个文件a, b, c的索引节点、权限、属主、大小、时间等属性：
（8）删除文件a：
（9）观察文件b, c是否仍然存在：
（10）查看文件b的内容：
13. 文件符号链接（软链接）
（1）创建一个文件a：
（2）创建文件a的一个符号链接：
（3）创建文件a的一个复制版本：
（4）观察3个文件a, b, c的索引节点、权限、属主、大小、时间等属性：
（5）修改文件a中的内容。
（6）使用cat命令分别观察文件b和文件c的内容。
（7）再次观察3个文件a, b, c的索引节点、权限、属主、大小、时间等属性：
（8）删除文件a：
（9）观察文件b, c是否仍然存在：
（10）查看文件b的内容：
14. 写出分析程序执行结果，将_exit(0)换为exit(0)，再写出程序执行结果，并分析运行结果差异的原因。
/*exit1.c*/
#include <sys/types.h>
include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
main()
{
int p;
printf("this is parent1\n ");
p=fork();
if (p>0)
printf("this is parent2\n ");
else
{
printf("this is child first\n”);
printf("this is child second ”);
_exit(0);
}
}

15.
输出设备加锁程序：lockf2.c
/* lockf2.c*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
main( )
{
int p1,p2,i;
p1=fork( ); /*创建子进程p1*/
if (p1==0)
{
lockf(1,1,0); /*加锁，这里第一个参数为stdout（标准输出设备的描述符）*/
for(i=0;i<5;i++)
{
printf("child1=%d\n",i);
sleep(2);
}
lockf(1,0,0); /*解锁*/
}
else
{
p2=fork(); /*创建子进程p2*/
if (p2==0)
{
lockf(1,1,0); /*加锁，第一个参数为stdout（标准输出设备的描述符）*/
for(i=0;i<5;i++)
{
printf("child2= %d\n",i);
sleep(2);
}
lockf(1,0,0); /*解锁，第一个参数为stdout（标准输出设备的描述符）*/
}
else
{
lockf(1,1,0); /*加锁*/
for(i=0;i<5;i++)
{
printf(" parent %d\n",i);
sleep(2);
}
lockf(1,0,0);/*解锁*/
}
}
}
程序说明：
按以下步骤分析上面的程序
l 将程序中所有的lockf()函数加上注释，再观察程序执行结果并估算程序执行所需的时间。
l 分析程序两次执行的结果与时间的区别。