操作系统课内实验报告.docx

西安交通大学实验报告
操作系统实验报告
刘烜
2130505133
计算机36班

操作系统实验
实验一：用户接口实验
实验目的
1) 理解面向操作命令的接口Shell。
2) 学会简单的shell编码。
3) 理解操作系统调用的运行机制。
4) 掌握创建系统调用的方法。
操作系统给用户提供了命令接口和程序接口（系统调用）两种操作方式。用户接口实验也因此而分为两大部分。首先要熟悉Linux的基本操作命令，并在此基础上学会简单的shell编程方法。然后通过想Linux内核添加一个自己设计的系统调用，来理解系统调用的实现方法和运行机制。在本次实验中，最具有吸引力的地方是：通过内核编译，将一组源代码变成操作系统的内核，并由此重新引导系统，这对我们初步了解操作系统的生成过程极为有利。
实验内容
1) 控制台命令接口实验
该实验是通过“几种操作系统的控制台命令”、“终端处理程序”、“命令解释程序”和“Linux操作系统的bash”来让实验者理解面向操作命令的接口shell和进行简单的shell编程。
Ø 查看bash版本。
在 shell 提示符下输入：
$echo $BASH_VERSION
我们的版本是4.3.42(1)-release

（2）建立 bash 脚本，输出 Hello word
在编辑器中输入以下内容
#!/bin/bash
echo Hello World!

执行脚本 使用指令：
$./script

Ø 编写bash脚本，统计/my目录下c语言文件的个数
通过 bash 脚本，可以有多种方式实现这个功能，而使用函数是其中个一个选择。在使用函数之前，必须先定义函数。 进入自己的工作目录，编写名为 count 的文件 脚本程序：
#! /bin/bash
function count
{
echo –n " Number of matches for $1: " #接收程序的第一个参数
ls $1|wc –l #对子程序的第一个参数所在的目录进行操作
}
将 count 文件复制到当前目录下，然后在当前目录下建立文件夹，在 my 目录下建立几个 c 文件,以便用来进行测试
2) 系统调用实验
该实验是通过实验者对“Linux操作系统的系统调用机制”的进一步了解来理解操作系统调用的运行机制；同时通过“自己创建一个系统调用mycall（）”和“编程调用自己创建的系统调用”进一步掌握创建和调用系统调用的方法。
Ø 编程调用一个系统调用fork（），观察结果。
在应用程序中调用系统调用fork（）非常简单，下面的程序可以很清楚的显示出有fork（）系统调用生成了子进程，而产生的分叉作用：
# include <stdio.h>
int main()
{
int iUid;
iUid=fork();
if(iUid==0)
for(;;) { printf("This is child process.\n");
sleep(1);
}
if(iUid>0)
for(;;) {
printf("This is parent process.\n");
sleep(1);
}
if(iUid<0) printf("Can not use system call.\n");
return 0;
}
程序运行结果：

Ø 编程调用创建的系统调用foo（），观察结果。
在内核源码中添加如下代码：
asmlinkage int sys_foo（int x）
{ printf（“%d\n”,x）;
}
编程调用创建的系统调用 foo（），观察结果。
#include <stdio.h>
#include <linux/unistd.h>
_syscall1(char*,foo,int,ret)
main()
{
int I,J; I=100; J=0; J=foo(I);
printf("This is the result of new kernel\n");
printf("%d",j);
}
重新编译内核，编译成功后的内核版本如下：

Ø 自己创建一个系统调用mycall（），实现功能：显示字符串到屏幕上。
在内核源码中添加如下代码：
#include<linux/linkage.h>
asmlinkage long sys_newcall(int i)
{
//printk("this is a system call made by yourself\n");
return(i*10);
}
测试新的System_call
CODE: vi test.c

Ø 编程调用自己创建的系统调用。
测试：CODE:./test

实验体会：
通过本次实验，我们理解了面向操作命令的接口 Shell，学会了简单的 shell 编码，理解 了操作系统调用的运行机制，掌握了创建系统调用的方法。本次实验通过内核编译，将一组 源代码变成操作系统的内核，并由此重新引导系统，这让我们初步了解了操作系统的生成过程。
实验二：进程管理实验
实验目的
1) 加深对进程概念的理解，明确进程和程序的区别。
2) 进一步认识并发执行的实质。
3) 分析进程争用资源的现象，学习解决进程互斥的方法。
4) 了解Linux系统中进程通信的基本原理。
进程是操作系统中最重要的概念，贯穿始终，也是学习现代操作系统的关键。通过本次实验，要求理解进程的实质和进程管理的机制。在Linux系统下实现进程从创建到终止的全过程，从中体会进程的创建过程、父进程和子进程的关系、进程状态的变化、进程之间的同步机制、进程调度的原理和以信号和管道为代表的进程间通信方式的实现。
实验内容
1) 编制实现软中断通信的程序
1.实验原理：
使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上发出的中断信号（即按delete键），当父进程接收到这两个软中断的某一个后，父进程用系统调用kill()向两个子进程分别发出整数值为16和17软中断信号，子进程获得对应软中断信号，然后分别输出下列信息后终止：
Child process 1 is killed by parent !!
Child process 2 is killed by parent !!
父进程调用wait()函数等待两个子进程终止后，输入以下信息，结束进程执行：
Parent process is killed!!
2.实验源码：
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
int wait_flag;
void stop( );
main( ) {
int pid1, pid2; // 定义两个进程号变量
signal(3,stop); // 或者 signal(14,stop);
while((pid1 = fork( )) == -1); // 若创建子进程1不成功,则空循环
if(pid1 > 0) { // 子进程创建成功,pid1为进程号
while((pid2 = fork( )) == -1); // 创建子进程2
if(pid2 > 0) {
wait_flag = 1;
sleep(5); // 父进程等待5秒
kill(pid1,16); // 杀死进程1
kill(pid2,17); // 杀死进程2
wait(0); // 等待第1个子进程1结束的信号
wait(0); // 等待第2个子进程2结束的信号
printf("\n Parent process is killed !!\n");
exit(0); // 父进程结束
}
else {
wait_flag = 1;
signal(17,stop); // 等待进程2被杀死的中断号17
printf("\n Child process 2 is killed by parent !!\n");
exit(0);
}
}
else {
wait_flag = 1;
signal(16,stop); // 等待进程1被杀死的中断号16
printf("\n Child process 1 is killed by parent !!\n");
exit(0);
}
}
void stop( ) {
wait_flag = 0;
}
3.程序运行结果:

或者多次运行，并且Delete键后，会出现如下结果：

4.简要原因分析：
上述结果中“Child process 1 is killed by parent !!” 和“Child process 2 is killed by parent !!”相继出现，当运行几次后，谁在前谁在后是随机的。这是因为：从进程调度的角度看，子进程被创建后处于就绪态。此时，父进程和子进程作为两个独立的进程，共享同一个代码段，分别参加调度、执行，直至进程结束。但是谁会先被调度程序选中执行，则与系统的调度策略和系统当前的资源状态有关，是不确定的。因此，谁先从fork()函数中返回继续执行后面的语句也是不确定的。
2) 编制实现进程的管道通信的程序
1.实验原理：
使用系统调用pipe()建立一条管道线，两个子进程分别向管道写一句话：
Child process 1 is sending a message!
Child process 2 is sending a message!
而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求：父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息。
2.程序源码：
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
int pid1,pid2; // 定义两个进程变量
main( ) {
int fd[2];
char OutPipe[100],InPipe[100]; // 定义两个字符数组
pipe(fd); // 创建管道
while((pid1 = fork( )) == -1); // 如果进程1创建不成功,则空循环
if(pid1 == 0) { // 如果子进程1创建成功,pid1为进程号
lockf(fd[1],1,0); // 锁定管道
sprintf(OutPipe,"\n Child process 1 is sending message!\n"); // 给Outpipe赋值
write(fd[1],OutPipe,50); // 向管道写入数据

sleep(5); // 等待读进程读出数据
lockf(fd[1],0,0); // 解除管道的锁定
exit(0); // 结束进程1
}
else {
while((pid2 = fork()) == -1); // 若进程2创建不成功,则空循环
if(pid2 == 0) {
lockf(fd[1],1,0);
sprintf(OutPipe,"\n Child process 2 is sending message!\n");
write(fd[1],OutPipe,50);
sleep(5);
lockf(fd[1],0,0);
exit(0);
}
else {
wait(0); // 等待子进程1 结束
read(fd[0],InPipe,50); // 从管道中读出数据
printf("%s\n",InPipe); // 显示读出的数据
wait(0); // 等待子进程2 结束
read(fd[0],InPipe,50);
printf("%s\n",InPipe);
exit(0); // 父进程结束
}
}
}
3.运行结果截图：

4.简要分析
管道，是指用于连接一个读进程和一个写进程，以实现它们之间信息的共享文件又称pipe文件。向管道（共享文件）提供输入的发送进程（即写进程），以字符流形式将大量的数据送入管道；而接收管道输送的接收进程（读进程），可以从管道中接收数据。
为了协调双方的通信，管道通信机制必须提供以下3方面的协调能力：
Ø 互斥。当一个进程正在对pipe进程读/写操作时，另一进程必须等待，程序中使用lock(fd[1],1,0)函数实现对管道的加锁操作，用lock(fd[1],0,0)解除管道的锁定。
Ø 同步。当写进程把一定数量的数据写入pipe后，便去睡眠等待，直到读进程取走数据后，再把它唤醒。当读进程试图从一空管道中读取数据时，也应睡眠等待，直至写进程将数据写入管道后，才将其唤醒。
Ø 判断对方是否存在。只有确定写进程和读进程都存在的情况下，才能通过管道进行通信。
5）实验体会：
通过本次实验，我们理解了进程的实质和进程管理的机制。进程是操作系统中最重要的 概念，是现代操作系统的关键。实验中我们在 Linux 系统下实现进程从创建到终止的全过程， 体会了进程的创建过程、父进程和子进程的关系、进程状态的变化、进程之间的同步机制、 进程调度的原理和以信号和管道为代表的进程间通信方式的实现。
实验三 存储器管理实验
实验目的
1) 理解内存页面调度的机理
2) 掌握几种理论页面置换算法的实现方法
3) 了解HASH数据结构的使用
4) 通过实验比较几种调度算法的性能优劣
页面置换算法是虚拟存储管理实现的关键，通过本次实验理解内存页面调度的机制，在模拟实现FIFO、LRU、NRU和OPT几种经典页面置换算法的基础上，比较各种页面置换算法的效率及优缺点，从而了解虚拟存储实现的过程。
准备知识
（1） C++、指针、结构体（类）
（2） HASH表查找方式
（3） 操作系统相关内存交换知识
（4） 用到的LINUX函数
int getpid() 获得当前进程的id
void srand ( int a ) 以a为种子产生随机数
int rand() 根据前面的种子，返回一个随机数
实验内容
程序整体截图：

对比以下几种算法的命中率：
1) 先进先出算法FIFO（First In First Out）
运行结果截图：

2) 最近最少使用算法LRU（Least Recently Used）
运行结果截图：

3) 最佳置换算法OPT（Optimal Replacement）
运行结果截图：

实验四 文件系统实验
实验目的
1) 掌握文件系统的工作机理。
2) 理解文件系统的主要数据结构。
3) 学习较为复杂的LINUX下的编程
实验内容
1) 设计并实现一个一级（单用户）文件系统程序
a.提供以下操作：
Ø 文件创建/删除接口命令create/delete
Ø 目录创建/删除接口命令mkdir/rmdir
Ø 显示目录内容命令ls
b.创建的文件不要求格式和内容
2) 设计并实现一个二级文件系统程序
a.提供用户登录；
b.文件、目录要有权限
3） 程序设计思想
设计一个简单的文件系统，包括格式化、显示目录（文件）、创建文件、登录等几个简单命令的实现，而且能完成超级块的读写、节点的读写等过程。这是一个比真正的文件系统简单得多、但又能基本体现文件系统理论的程序。在超级块的使用上，采用操作系统关于这方面的经典理论：在节点使用上，主要模仿LINUX的EXT2文件系统。
4）程序截图：

5)实验体会：
通过本次实验，我们理解了内存页面调度的机制，掌握了几种理论页面置换算法的实现 方法，了解了 HASH 数据结构的使用。页面置换算法是虚拟存储管理实现的关键，FIFO、 LRU、NRU 和 OPT 是几种经典页面置换算法，我们通过实现这几种算法，比较了较各种页 面置换算法的效率及优缺点，从而了解了虚拟存储实现的过程。
程序源代码：（部分源码截图）

存储器管理实验源代码部分截图：

文件系统实验源代码部分截图：