操作系统原理--课程设计报告.docx

课 程 设 计 报 告

课程名称：操作系统原理

院 系 ： 计算机科学与技术
专业班级 ： CS140 ____ __
学 号 ： U201414_____
姓 名 ： ______ ___
指导教师 ： _______ __
完成时间 ： 2017年3月11日_

华 中 科 技 大 学 课 程 设 计 报 告

目 录
1 实验目的 2
2 实验环境 2
3 实验内容 2
3.1 实验一 2
3.2 实验二 2
3.3 实验三 3
3.4 实验四 3
3.5 实验五（选做） 3
4 设计与实现 3
4.1 实验一 3
4.2 实验二 6
4.3 实验三 9
4.4 实验四 11
5 心得体会 14

32
1 实验目的
·掌握Linux操作系统的使用方法；
·了解Linux系统内核代码结构；
·掌握实例操作系统的实现方法；
2 实验环境
本次课程设计采用的操作系统环境是windows10、Ubuntu双系统，Ubuntu系统版本号为16.04，内核版本号为linux 4.4.4；前两个实验在当前Ubuntu环境下完成，后两个实验在win10下虚拟机VirtualBox的Ubuntu 15.10（内核为linux4.2.0-42） 中完成。
3 实验内容
3.1 实验一
要求熟悉和理解Linux下的编程环境。
（1）编写一个C程序，用fread、fwrite等库函数实现文件拷贝功能。
（2）编写一个C程序，使用基于文本的终端图形编程库(curses)或图形界面(QT/GTK），分窗口显示三个并发进程的运行(一个窗口实时显示当前时间，一个窗口实时监测CPU的利用率，一个窗口做1到100的累加求和，刷新周期分别为1秒，2秒和3秒)。
3.2 实验二
要求掌握添加系统调用的方法，采用编译内核方法，添加一个新的系统调用，实现文件拷贝的功能，另外编写一个应用程序，测试新增加的系统调用。
3.3 实验三
掌握增加设备驱动程序的方法。采用模块方法，添加一个新的字符设备驱动程序，实现打开/关闭，读/写等基本操作。另外编写一个应用程序，测试新添加的驱动程序。
3.4 实验四
要求理解和分析/proc文件。
（1）了解/proc文件的特点和使用方法；
（2）监控系统状态，显示系统部件的使用状态；
（3）用图形界面实现系统监控状态，包括CPU和内存利用率、所有进程信息等（可自己补充、添加其他功能）；
3.5 实验五（选做）
要求理解和掌握文件系统的设计方法（选做）。
设计、实现一个模拟的文件系统。包括文件/目录创建/删除，目录显示等基本功能（可自行扩充文件读/写、用户登录、权限控制、读写保护等其他功能）。

4 设计与实现
4.1 实验一
4.1.1 实验要求
要求熟悉和理解Linux下的编程环境。
4.1.2 实验设计及调试
（1）编写一个C程序，其内容为实现文件拷贝的功能。
这个实验的思路是声明两个文件指针*fp_read和*fp_write，前者用来打开要读的文件，后者打开要写的文件，再创建一个1000个字节大小的缓冲区buff[]，然后调用fread将内容从文件1读到buff里，再调用fwrite把内容从buff写到文件2中。这个实验重点要掌握fread和fwrite的使用方法，注意它们的参数和返回值。代码见附件中源码。实验结果如下图4.1：

图4.1 运行之前图
运行./lab1_1 text1.txt text2.txt后结果如下图4.2：

图4.2 运行之后图
由上图可见text1.txt成功拷贝至text2.txt

（2）编写一个C程序，本次实验使用的是图形界面GTK，分窗口显示三个并发进程的运行(一个窗口实时显示当前时间，一个窗口实时监测CPU的利用率，一个窗口做1到100的累加求和，刷新周期分别为1秒，2秒和3秒)。
这个实验要用到gtk，首先要配置gtk，在终端中输入：
sudo apt-get install libgtk2.0-dev
涉及到3个进程的并发，所以要调用函数fork来创建3个进程。我的思路是在这3个进程中分别创建一个线程，去完成相应的功能：显示当前时间，监测CPU利用率，做累加求和。分别通过函数void havetime()、void cpu_usage()、void add()实现，在main函数里，初步画出3个进程相应的界面。具体的是调用gtk_window_new（）函数创建一个窗口、gtk_window_set_title（）设置窗口标题、gtk_window_set_position设置窗口在屏幕的位置、gtk_label_new（）创建一个标签用来显示文本、gtk_container_add（）把标签添加到窗口中、gtk_widget_show_all（）来展示需要展示的控件。例如创建第一个线程：
g_thread_create((GThreadFunc)havetime, NULL, FALSE, NULL);
通过在线程havetime（）中实时更新标签label的内容，然后在main（）中创建的窗口中展示来完成所要求的功能。进程2和3所要求的功能也是通过这种方法实现。注意用到gtk的编译命令与以往不同，为：
gcc -o lab1_2 lab1_2.c `pkg-config --cflags --libs gtk+-2.0`
代码见附件中的源码，实验结果如下图4.3：

图4.3 运行结果图
小插曲：在调用sprintf(s,"CPU利用率为%f%% ",usage)想把利用率的“%”拷进缓冲区s后打印出来时，一个百分号是不能够打印出来的，要写两个%，如想要打印两个%,则要写4个%，以此类推。
4.2 实验二
4.2.1 实验要求
要求掌握添加系统调用的方法，采用编译内核方法，添加一个新的系统调用，实现文件拷贝的功能，另外编写一个应用程序，测试新增加的系统调用。
4.2.2 实验设计及调试
（1） 下载一个内核https://www.kernel.org/pub/linux/kernel/v4.x/
下载linux-4.4.4.tar.gz
在 /usr/src/ 目录下解压（用超级用户权限），

（2） 编写新的系统调用程序
用户空间所使用的open、read、write、close函数此时对应内核函数为 sys_open、 sys_read、 sys_write、 sys_close。
首先通过sys_open()打开源文件和目标文件，分别返回文件描述符source和dest，然后把当前的用户地址范围保存在fs，再把当前内存访问地址范围设置为内核的内存地址访问范围，再通过sys_read()把源文件内容写到buf，再用sys_write()把buf内容写到dest，接着用sys_close()来关闭文件，最后再把内存访问地址范围设置为用户的。保存fs是避免使用的缓冲区超过了用户空间的地址范围而报错。
把自己写的这个系统调用程序添加至/usr/src/linux-4.4.4/kernel目录下的sys.c最后。

（3） 添加系统调用号
在 /usr/src/linux-4.4.4/arch/x86/entry/syscalls目录下修改 syscall_64.tbl 文件，添加一个自己的调用程序的系统调用号，我的之前用到了325好，所以添加326号，如下：
326 common mysyscall sys_mysyscall
（4） 添加系统调用程序的声明
在/usr/src/linux-4.4.4/include/linux 目录下的syscalls.h最后加上自己添加的系统调用程序的声明如下：
asmlinkage int sys_mysyscall(char* sourceFile,char* destFile);

（5） 编译、安装内核
在 /usr/src/linux-4.4.4 目录下对内核选项进行配置：
sudo make menuconfig

图4.4 内核配置图
选择save后退出
接下来就是漫长的编译内核了（4个线程跑会快一些）：
sudo make -j 4
大概1个小时左右编译完毕，再安装内核：
sudo make modules_install //安装内核模块
sudo make install //安装内核
安装完毕后重启，在Ubuntu高级选项中进入新的内核。

（6） 编写系统调用测试程序
#include <sys/syscall.h>
#include <unistd.h>

int main(){
syscall(326,"text1.txt","text2.txt");
return 0;
}
实验结果如下图4.5：

图4.5 运行之前的图
./lab2 后如下图：

图4.6 运行之后的图
可见系统调用成功。

4.3 实验三
4.3.1 实验要求
掌握增加设备驱动程序的方法。采用模块方法，添加一个新的字符设备驱动程序，实现打开/关闭，读/写等基本操作。另外编写一个应用程序，测试新添加的驱动程序。
4.3.2 实验设计及调试
（1）添加设备驱动原理：linux设备一般分为：字符设备、块设备和网络设备。驱动程序运行在内核空间，应用程序通常通过文件系统接口函数访问/dev目录下的设备文件来访问驱动程序。编写设备驱动程序的主要工作就是编写file_operations子函数，这次实验主要完成的就是file-operations数据结构中的.open\.release\.read\.write4个模块，file_operations结构的每个域都对应一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write等操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取该数据结构相应的函数指针，接着把控制权交给该函数。
（2） 编写Makefile文件
Makefile文件用于编译设备驱动程序，其内容如下：
iifeq ($(KERNELRELEASE),)
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
modules_install:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
.PHONY: modules modules_install clean
else
obj-m := mydev.o
endif
（3） 编写设备功能函数
编写设备驱动程序的主要工作就是编写子功能函数。
open（）函数用来打开一个设备，在该函数中可以对设备进行初始化。如果这个函数被赋值NULL，那么设备打开永远成功，并不会对设备产生影响。
release（）函数用来释放open（）函数中申请的资源，并在文件引用计数为0时，被系统调用。其对应应用程序的close（）方法，但并不是每一次调用close（）方法，都会触发release（）函数，只有在打开的所有设备文件都释放后，该函数才会被调用。
read（）函数用来从设备中获取数据，成功时返回读取的字节数，失败时返回一个负的错误码。
write（）函数用来写数据到设备中。成功时该函数返回写入的字节数。
详细实现见附件中源码。

（4） 设备驱动程序安装
① make，调用Makefile编译设备驱动程序

图4.7 make图
编译成功，生成mydev.ko文件

② sudo insmod mydev.ko 挂载模块，再查看设备的主设备号：
cat /proc/devices

图4.8 主设备号的图
可见系统为mydev生成的主设备号为248

③ sudo /dev/mydev c 248 0
mydev是设备文件的名字，“c”是指创建的是字符设备文件，248是主设备号，0是从设备号。

图4.9 生成设备文件图
可见生成了正确的设备文件mydev
（5） 测试驱动程序
测试程序实现的是先从设备中读出里面初始的字符串U201414813，再把一个字符串写进去，然后再读出来，测试程序详见附件源码，测试实验结果如下图：
先运行命令执行程序：sudo ./test

图4.10 结果图
可见打开、读、写均正确。
最后执行 sudo rmmod mydev 来删除模块
sudo rm /dev/mydev 来删除设备文件

4.4 实验四
要求理解和分析/proc文件。
4.4.1 实验要求
了解/proc文件的特点和使用方法；监控系统状态，显示系统部件的使用状态；用图形界面实现系统监控状态，包括CPU和内存利用率、所有进程信息等（可自己补充、添加其他功能）。
4.4.2 实验设计及调试
这个实验主要是对/proc文件的理解和对gtk的熟练运用。我用gtk里的笔记本构件画了3个页面，分别为page one、page two、page three。
page one：显示CPU利用率
计算和显示CPU直接用到的实验一第二个部分的显示CPU利用率部分，不同的是这儿用到了笔记本控件，要把“page one”作为一个button加到notebook上，还要把算出来的CPU利用率作为一个标签内容加到notebook上，即：
GtkWidget *button4 = gtk_label_new("Page one");
label1 = gtk_label_new("begin");//全局标签
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), label1, button4);//笔记本容器、子控件、标题名
然后创建一个线程去计算CPU利用率，然后实时更新显示出来。
page two：显示所有进程信息
用gtk来画这个界面的逻辑是：最大的逻辑控件是笔记本notebook，把一个hbox添加到notebook里，再把显示所有进程信息的表clist添加到一个滚动窗口scrolled_window里，再把这个scrolled_window添加到hbox左边部分；hbox右边部分包括一个vbox，这个vbox上面是一个frame来显示进程大致情况，下面是一个button用来刷新进程。如下图4.11：

notebook
hbox

vbox

scrolled_window

frame

clist

button

图4.11 构件分布结构图
clist中所有进程信息是通过void get_proc_info(GtkWidget *clist,int *p,int *q,int *r,int *s)函数读出来的，具体就是遍历/proc文件夹下所有的数字文件夹，这些数字文件夹的stat中存放的就是所有进程的部分信息，包括：PID、名称、状态、优先级、占用内存，直接遍历读出来后加到clist中显示出来。同样，frame中的总进程数、运行进程数、睡眠进程数、僵尸进程数也都是根据get_proc_info（）遍历时统计出来的。刷新按钮要实现的功能其实就是再次读出所有的进程信息并显示出来，通过void refresh(GtkWidget *clist)函数实现。
GtkWidget *button2 = gtk_button_new_with_label("刷新");
g_signal_connect_swapped (G_OBJECT (button2), "clicked",G_CALLBACK (refresh), clist);
当button2上发生click事件时就调用refresh完成刷新。

page three：显示一些基本的CPU信息
这页就是简单的创建两个frame1和frame2来显示CPU部分信息和操作系统的部分信息。
frame1中：CPU名称通过char* get_cpu_name(char *buf1)函数获得，CPU类型通过char* get_cpu_type(char *buf2)函数获得，CPU主频通过char* get_cpu_f(char *buf3)函数获得，这3个信息都是从/proc/cpuinfo中读出来的，其中涉及到一些简单的字符串的判断等操作，在此不加赘述；
frame2中：操作系统名称是通过char *get_os_type(char *buf1)函数获得的，操作系统版本是通过char *get_os_version(char *buf2)函数获得的，它们都返回一个缓冲区指针，用以在主函数main（）中显示。
3个页面的详细代码见附件中源码。
编译：gcc -o lab4 lab4.c `pkg-config --cflags --libs gtk+-2.0`
执行：./lab4
实验结果如下图4.12、4.13、4.14：

图4.12 第一个页面图

图4.13 第二个页面图

图4.14 第三个页面图

5 心得体会
本次课程设计，第一个题目第一问很简单，因为之前在实验中写过文件拷贝的程序，所以很快就顺利实现了，要注意fopen、fread、fwrite几个函数的用法，第二问刚开始不知怎么做，主要是因为之前没接触过gtk这种画界面的环境，在网上查阅相关资料后发现套路都是一样的，个人觉得把握住gtk中控件的概念，实现简单的界面都还是比较简单的，除了gtk，在CPU利用率的计算上还卡了一段时间，主要是没弄清到底应该怎么计算，查了大量资料后找到一种比较简单的计算方法去实现，结果也很准确；第二题和第三题是同一类型，都是需要对内核、系统调用、设备驱动文件有很好的理解才能很快做出来，自己还掌握得不是很好，所以也花了不少的时间去查资料、实现要求的功能，但现在回过头来看收获很大，对课上所学的部分内容有了更加深刻的理解，对linux系统调用和设备文件有了更深的认识；第四题确实是花的时间最多的，因为不仅涉及到复杂的gtk运用，还包括对/proc文件的理解，这两方面都是查了大量资料后才一点点完成的，时间花了，确实也有了成效，看到自己画的界面和读出的进程、CPU信息，成就感瞬间爆棚，但这还远远不够，相信以后学习工作中还会遇到更加困难的类似的问题，这次课设只是打下了个小小的基础，任重道远！总之，这次课设受益匪浅。

6 附录（源码）
实验一：
第一题：
#include <stdio.h>
#define buffer_size 1000

int main(int argc,char *argv[])
{
if(argc != 3) //输入3个参数
{
printf("input error!\n");
return 0;
}
char buff[buffer_size] = {0}; //缓冲区初始化为'\0'
int nread = 0;
FILE *fp_read = NULL;
FILE *fp_write = NULL;
if((fp_read = fopen(argv[1],"rb")) == NULL)
{
printf("can't open %s",argv[1]);
return 1;
}
if((fp_write = fopen(argv[2],"wb")) == NULL)
{
printf("can't open %s",argv[2]);
return 1;
}
while((nread = fread(buff,sizeof(char),buffer_size,fp_read))>0) //实际读到字符数nread
fwrite(buff,sizeof(char),nread,fp_write);
fclose(fp_read);
fclose(fp_write);
return 0;
}
第二题：
#include <gtk/gtk.h>
#include <time.h>
#include <unistd.h>

GtkWidget*window;
GtkWidget*label;

void havetime(){
int i;

for(;;i++){

time_t timer = time(NULL);
char s[1000] = {0};
sprintf(s,"local time is %s",ctime(&timer));//格式化字符串写入s
/*sleep for a second*/
sleep(1);
gdk_threads_enter();
gtk_label_set_text(GTK_LABEL(label),s);
gdk_threads_leave();
}
}

void cpu_usage(){
FILE *fp;
char cpu[5];
char buff[1000] = {0};
char s[1000] = {0};
long int user,nice,sys,idle,iowait,irq,softirq;
long int s1,s2,idle1,idle2;
float usage;
while(1){
fp = fopen("/proc/stat","r");
if(fp == NULL){
perror("fopen");
exit(0);
}
fgets(buff,sizeof(buff),fp); //从文件结构体指针中读取数据
sscanf(buff,"%s%d%d%d%d%d%d%d",cpu,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);
s1 = user+nice+sys+idle+iowait+irq+softirq;
idle1 = idle;
rewind(fp);
sleep(1);
//memset(buff,0,sizeof(buff));
//cpu[0] = '\0';
user = nice = sys = idle = iowait = irq = softirq = 0;
fgets(buff,sizeof(buff),fp);
sscanf(buff,"%s%d%d%d%d%d%d%d",cpu,&user,&nice,&sys,&idle,&iowait,&irq,&softirq);
s2 = user+nice+sys+idle+iowait+irq+softirq;
idle2 = idle;
usage = (float)(s2 - s1 - (idle2-idle1))/(s2 - s1)*100;
sprintf(s,"CPU利用率为%f%% ",usage);
gdk_threads_enter();
gtk_label_set_text(GTK_LABEL(label),s);
gdk_threads_leave();

fclose(fp);
sleep(1);
}
}

void add(){

int j = 1;
int sum = 0;
int sum1 = 0;
for(;j<101;j++){
sum1 = sum+j;
char s[1000] = {0};
sprintf(s,"%d + %d = %d",sum,j,sum1);
sleep(3);

gdk_threads_enter();
gtk_label_set_text(GTK_LABEL(label),s);
gdk_threads_leave();
sum = sum1;
}
}

int main(int argc,char *argv[])
{
int pid_1,pid_2,pid_3;

if((pid_1 = fork()) == 0){
gtk_init(&argc,&argv);

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"child 1 progress");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_NONE);
gtk_container_set_border_width(GTK_CONTAINER(window),100);

label = gtk_label_new("now let's begin!");
gtk_container_add(GTK_CONTAINER(window),label);

gtk_widget_show_all(window);

g_signal_connect(window,"destroy",G_CALLBACK(gtk_main_quit),NULL);
/*线程的初始化*/
if(!g_thread_supported()) g_thread_init(NULL);
gdk_threads_init();
/*创建线程*/
g_thread_create((GThreadFunc)havetime, NULL, FALSE, NULL);
}

else if((pid_2 = fork()) == 0){
gtk_init(&argc,&argv);

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"child 2 progress");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_NONE);
gtk_container_set_border_width(GTK_CONTAINER(window),100);

label = gtk_label_new("now let's begin!");
gtk_container_add(GTK_CONTAINER(window),label);

gtk_widget_show_all(window);

g_signal_connect(window,"destroy",G_CALLBACK(gtk_main_quit),NULL);
/*线程的初始化*/
if(!g_thread_supported()) g_thread_init(NULL);
gdk_threads_init();
/*创建线程*/
g_thread_create((GThreadFunc)cpu_usage, NULL, FALSE, NULL);
}

else if((pid_3 = fork()) == 0){
gtk_init(&argc,&argv);
/*窗口初始化*/
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"child 3 progress");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_NONE);
gtk_container_set_border_width(GTK_CONTAINER(window),100);
/*标签*/
label = gtk_label_new("now let's begin!");
gtk_container_add(GTK_CONTAINER(window),label);

gtk_widget_show_all(window);

g_signal_connect(window,"destroy",G_CALLBACK(gtk_main_quit),NULL);
/*线程的初始化*/
if(!g_thread_supported()) g_thread_init(NULL);
gdk_threads_init();
/*创建线程*/
g_thread_create((GThreadFunc)add, NULL, FALSE, NULL);
}

gdk_threads_enter();
gtk_main ();
gdk_threads_leave();
return 0;
}

实验二：
sys.c:
asmlinkage int sys_mysyscall(char* sourceFile,char* destFile){
int source=sys_open(sourceFile,O_RDONLY,0);
int dest=sys_open(destFile,O_WRONLY|O_CREAT|O_TRUNC,0600);
char buf[4096];
mm_segment_t fs;
fs = get_fs();
set_fs(get_ds()); //设置为内核的内存访问地址范围
int i;
if(source>0 && dest>0)
{
do
{
i=sys_read(source,buf,4096);
sys_write(dest,buf,i);
}while(i);
}
sys_close(source);
sys_close(dest);
set_fs(fs);
return 10;
}
test.c:
#include <sys/syscall.h>
#include <unistd.h>

int main(){
syscall(326,"text1.txt","text2.txt");
return 0;
}

实验三：
mydev.c:
#include "linux/kernel.h"
#include "linux/module.h"
#include "linux/fs.h"
#include "linux/init.h"
#include "linux/types.h"
#include "linux/errno.h"
#include "linux/uaccess.h"
#include "linux/kdev_t.h"
#define BUFFER_SIZE 1024

static int my_open(struct inode *inode, struct file *file);
static int my_release(struct inode *inode, struct file *file);
static ssize_t my_read(struct file *file, char __user *user, size_t t, loff_t *f);
static ssize_t my_write(struct file *file, const char __user *user, size_t t, loff_t *f);

static char message[BUFFER_SIZE] = "U201414813";
static int device_num = 0;//
static int counter = 0;//

static char* devname = "mydev";

struct file_operations pstruct = {
.read = my_read,
.write = my_write,
.open = my_open,
.release = my_release
};

int init_module(){
int ret;
ret = register_chrdev(0,devname,&pstruct);
if(ret < 0){
printk("regist failure\n");
return -1;
}
else {
printk("the device has been registered!\n");
device_num = ret;
printk("<1>the virtual device's major number %d.\n", device_num);
printk("<1>Or you can see it by using\n");
printk("<1>------more /proc/devices-------\n");
printk("<1>To talk to the driver,create a dev file with\n");
printk("<1>------'mknod /dev/myDevice c %d 0'-------\n", device_num