Linux内核实验报告 - 实验4

(此文档为word格式，下载后您可任意编辑修改！)

Linux内核实验报告

实验题目： 动态模块设计实验

实验目的：

Linux 模块是一些可以独立于内核单独编译的内核函数和数据类型集合,是可增删的

内核部分。模块在内核启动时装载称为静态装载,在内核已经运行时装载称为动态装载。

模块可以扩充内核所期望的任何功能,但通常用于实现设备驱动程序。

通过本实验，将学习到动态模块的设计过程，以及Proc文件系统的部分知

识。

硬件环境：

Pentium(R) Dual-Core CPU T4400 @ 2.20GHz

软件环境： Ubuntu12.04

gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) 内核版本：3.0.24

实验步骤：

1、 代码分析

模块初始化和模块卸载的函数都类同，同时读取proc文件的函数在本次实验中没有用到，所以着重描述写驱动函数。 实验A：

在这个proc函数中只是简单得输出jiffies的数值。

实验B：遍历父进程和所有进程，依然是在proc_read中，通过以下代码片段完成功能，注意在这里，我们是通过直接向系统分配的那一个page直接写入来得到的，所以每次不同的进程访问该proc文件的时候得到的结果都不一样 遍历父进程：

len += sprintf(page+len,\遍历父进程\\npid\\tppid\\tcomm\\n\ while (task != &init_task){ len += sprintf(page len,\ task = task->parent; } 遍历所有进程，通过for_each_process(task)这个宏来遍历所有进程： len += sprintf(page + len,\遍历任务队列\\ncomm\\tpid\\n\ for_each_process(task){ len += sprintf(page + len,\ } return len; 实验C：

在模块开头通过module_param声明了模块参数，在装载模块时通过它来传参 module_param(param,int,0644); + 在proc_read函数中通过这个传入的参数来判断应该读取内核的哪些数值，其中标注黄色的一段是从内核实现/proc/loadavg部分中抽取出来的，loops_per_jiffy是每个滴答能执行的循环数，在内核启动的时候计算出来的这个值：

if (param == 0){ //获取loadavg len += sprintf(page + len, \ LOAD_INT(avenrun[0]), LOAD_FRAC(avenrun[0]), LOAD_INT(avenrun[1]), LOAD_FRAC(avenrun[1]), LOAD_INT(avenrun[2]), LOAD_FRAC(avenrun[2]) /*,nr_running(), nr_threads,*/ /*task_active_pid_ns(current)->last_pid*/); }else if (param == 1){ len += sprintf(page + len,\ len += sprintf(page + len,\ffy/(5000/HZ)0); }

在这里我们还设计了改写loops_per_jiffy的方法： static int proc_write(struct file *file,const char* buffer,unsigned long count,void *data) { int len; char buf[16]; if (count > MYDATA_LEN)

} len = MYDATA_LEN; else len = count; copy_from_user(buf,buffer,len); loops_per_jiffy = simple_strtol(buf,NULL,10); return len; 2、 设计说明

实验A：对于读取时间，内核提供了do_gettimeofday这个函数，同时在对用

户也提供了一个系统调用gettimeofday，这两个获取当前时间的途径都是一样的（在x86上都是访问TSC寄存器——时间戳寄存器来获得时间值），所以一般都要比用jiffies滴答数获得的时间数要准确。

在进行这两种比较时，我们可以有两种策略，直接在proc文件中不停输出两者数值（jiffies和当前时间），或者proc文件只输出文件，在通过用户程序调用系统调用获得时间值再进行比较，在这里使用了第二种。

实验B：设计说明在代码分析中已经阐明 实验C：设计说明在代码分析中已经阐明

3、 调试记录 实验A：

可以看到在几次循环中，jiffies的值始终没有变，而gettimeofday的值确是一直在变，实际上我的机器的内核HZ设置的是250,也就是0.004秒发生一个滴答，所以滴答数要改变的话，gettimeofday的值至少要变化4000微秒，jiffies的值才能改变，这说明了gettimeofday的精确度逼jiffies的精确度要高（至少是在本次实验环境中）。

实验B：值得注意的是0号进程swapper进程，查资料发现它就是所谓的idle进程。 实验C： 1. 2.

结论分析与体会：

在本次实验中充分体会了动态模块的灵活性。可以在装载的时候传入参数，从而改变模块在以后的行为。proc文件并不是一开始就在哪里，而是动态生成，动态计算的。虽然对于用户来说proc文件与一般的文件都是有相同的行为，但是其本质确实生成内容而非读取内容的，在这里充分体现出了linux设计的灵活性，以及VFS提供的这种抽象级别的强大之处。通过对proc的学习，对于以后的调试工作也有一定的帮助。

另一方面，对于模块开发的过程也有了一定的了解，基本上对于一个模块，需要做的事就是：

1.包含必要的头文件

2.使用必要的宏声明模块初始化函数和模块卸载函数 3.实现函数

另一方面，编写模块时Makefile的编写也是值得注意的地方，在这里附上本次实验中用到的一份Makefile

obj-m := pm2.o MOD = pm2 all: make -C /lib/modules/$(shell uname -r)/build M=$(shell pwd) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(shell pwd) clean rmmod: sudo rmmod pm2 install: sudo insmod pm2.ko test: cat /proc/$(MOD)dir/$(MOD)file 程序完整源代码： 问题A：

#include #include #include #include #include #include

#include

#include //do_gettimeofday /*#include */ /*#include */ /*#include */ /*#include */ /*#include */ /*#include */

#define MODULE_NAME \#define MYDATA_LEN 16 //放用户空间传入的数据 struct my_proc_data{ char value[MYDATA_LEN]; };

struct my_proc_data mydata; //proc结构变量

static struct proc_dir_entry *example_dir; static struct proc_dir_entry *data_file; static int param;

module_param(param,int,0644);

/***********************v2*********************** //读文件myfile的读驱动函数

static int proc_read(char *buf,char **start,off_t off,int count,int *eof,void *data)

{ int len = 0 ; struct timeval tv; unsigned long j1; u64 j2; do_gettimeofday(&tv); j1 = jiffies; j2 = get_jiffies_64(); len += sprintf(buf + len,\ len += sprintf(buf + len,\ *start = buf; return len; }

*************************************************/

static int proc_read(char *buf,char **start,off_t off,int count,int *eof,void *data) { int len = 0 ; unsigned long j1; j1 = jiffies; len += sprintf(buf + len,\ *eof = 1; //区别?,不加似乎会在读取结束的时候多发一个不会成功的read请求 printk(KERN_ALERT \ count %d\\n\ return len; }

//写文件myfile的写驱动函数

static int proc_write(struct file *file,const char* buffer,unsigned long count,void *data) { int len; struct my_proc_data *mydatap = (struct my_proc_data *) data; if (count > MYDATA_LEN) len = MYDATA_LEN; else len = count; if (copy_from_user(mydatap->value,buffer,len)){//buffer 在user mode return -EFAULT;//?Bad address,why minus? } mydatap->value[len-1]='\\0'; return len; }

//装入模块

int init_module(void) {

//创建proc/myfile目录

example_dir = (struct proc_dir_enry *)proc_mkdir(\

if (example_dir == 0){ printk (\ return -1; } data_file = (struct proc_dir_entry *)create_proc_entry(\ if (data_file == 0){ remove_proc_entry(\ printk(\ return -ENOMEM; } strcpy(mydata.value,\ data_file->data = &mydata; data_file->read_proc = &proc_read; data_file->write_proc=&proc_write; //data_file->owner=THIS_MODULE; 在我的内核中该结构已经没有owner成员了 return 0; }

//卸载模块

void cleanup_module(void) { remove_proc_entry(\ remove_proc_entry(\ printk(\}

MODULE_LICENSE(\

MODULE_DESCRIPTION(\MODULE_AUTHOR(\

问题A用户测试程序： #include #include #include #include #include #include #define path \#define prefix \#define prelen 6 #define ITERNUM 10 //默认循环次数 int main(int argc,char * argv[]) {

}

int n;

if (argc >1 ){ n = atoi(argv[1]); }else { n = ITERNUM; }

FILE * fp = 0; char buf[16]; struct timeval tv; for ( ; n > 0 ; --n){ fp = fopen(path,\ printf(\ fclose(fp); gettimeofday(&tv,NULL); printf(\}

问题B：

#include #include #include #include #include #include

#include

#include //task_struct等 /*#include */

#define MODULE_NAME \#define MYDATA_LEN 16 #define PMDIR \#define PMFILE \//放用户空间传入的数据 struct my_proc_data{ char value[MYDATA_LEN]; };

struct my_proc_data mydata; //proc结构变量

static struct proc_dir_entry *example_dir; static struct proc_dir_entry *data_file; static int param;

module_param(param,int,0644); //读文件myfile的读驱动函数

static int proc_read(char *page,char **start,off_t off,int count,int *eof,void *data)

{ int len = 0; struct task_struct *task = current; struct my_proc_data * mydatap = (struct my_proc_data*)data; len += sprintf(page + len,\ len += sprintf(page+len,\遍历父进程\\npid\\tppid\\tcomm\\n\ while (task != &init_task){ len += sprintf(page len,\ task = task->parent; } /* task now points to init*/ len += sprintf(page len,\ /*len += sprintf(page len,\ len += sprintf(page + len,\遍历任务队列\\ncomm\\tpid\\n\ for_each_process(task){ /* this poinlessly prints the name and pid of each task*/ /*printk(\ len += sprintf(page + len,\ } return len; }

//写文件myfile的写驱动函数

static int proc_write(struct file *file,const char* buffer,unsigned long count,void *data) { int len; struct my_proc_data *mydatap = (struct my_proc_data *) data; if (count > MYDATA_LEN) len = MYDATA_LEN; else len = count; if (copy_from_user(mydatap->value,buffer,len)){//buffer 在user mode return -EFAULT;//?Bad address,why minus? } mydatap->value[len-1]='\\0'; return len; }

//装入模块

int init_module(void) {

//创建proc/myfile目录

example_dir = (struct proc_dir_enry *)proc_mkdir(PMDIR,NULL);

+

+ +

if (example_dir == 0){ printk (\ return -1; }

data_file = (struct proc_dir_entry *)create_proc_entry(PMFILE,0666,example_dir); if (data_file == 0){ remove_proc_entry(\ printk(\ return -ENOMEM; }

strcpy(mydata.value,\data_file->data = &mydata;

data_file->read_proc = &proc_read; data_file->write_proc=&proc_write;

//data_file->owner=THIS_MODULE; 在我的内核中该结构已经没有owner成员了 return 0; }

//卸载模块

void cleanup_module(void) { remove_proc_entry(PMFILE,example_dir); remove_proc_entry(PMDIR,NULL); printk(\}

MODULE_LICENSE(\

MODULE_DESCRIPTION(\MODULE_AUTHOR(\

问题C： #include #include #include #include #include #include #include #include //task_struct等 #include #include #include #include #define LOAD_INT(x) ((x) >> FSHIFT)

#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100) #define MODULE_NAME \#define MYDATA_LEN 16 #define PMFILE \#define PMDIR \//放用户空间传入的数据 struct my_proc_data{ char value[MYDATA_LEN]; };

struct my_proc_data mydata;

//proc结构变量

static struct proc_dir_entry *example_dir; static struct proc_dir_entry *data_file; static int param;

module_param(param,int,0644);

//读文件myfile的读驱动函数

static int proc_read(char *page,char **start,off_t off,int count,int *eof,void *data) { int len = 0; struct my_proc_data * mydatap = (struct my_proc_data*)data; if (param == 0){ //获取loadavg len += sprintf(page + len, \ LOAD_INT(avenrun[0]), LOAD_FRAC(avenrun[0]), LOAD_INT(avenrun[1]), LOAD_FRAC(avenrun[1]), LOAD_INT(avenrun[2]), LOAD_FRAC(avenrun[2]) /*,nr_running(), nr_threads,*/ /*task_active_pid_ns(current)->last_pid*/); }else if (param == 1){ len += sprintf(page + len,\ len += sprintf(page + len,\ffy/(5000/HZ)0); } return len; }

//写文件myfile的写驱动函数

static int proc_write(struct file *file,const char* buffer,unsigned long count,void *data) { int len; char buf[16]; if (count > MYDATA_LEN) len = MYDATA_LEN; else

len = count; copy_from_user(buf,buffer,len); loops_per_jiffy = simple_strtol(buf,NULL,10); return len; }

//装入模块

int init_module(void) { //创建proc/myfile目录 example_dir = (struct proc_dir_enry *)proc_mkdir(PMDIR,NULL); if (example_dir == 0){ printk (\ return -1; } data_file = (struct proc_dir_entry *)create_proc_entry(PMFILE,0666,example_dir); if (data_file == 0){ remove_proc_entry(PMFILE,0); printk(\ return -ENOMEM; } strcpy(mydata.value,\ data_file->data = &mydata; data_file->read_proc = &proc_read; data_file->write_proc=&proc_write; //data_file->owner=THIS_MODULE; 在我的内核中该结构已经没有owner成员了 return 0; }

//卸载模块

void cleanup_module(void) { remove_proc_entry(PMFILE,example_dir); remove_proc_entry(PMDIR,NULL); printk(\}

MODULE_LICENSE(\

MODULE_DESCRIPTION(\MODULE_AUTHOR(\

参考材料 lke2012.pdf

len = count; copy_from_user(buf,buffer,len); loops_per_jiffy = simple_strtol(buf,NULL,10); return len; }

//装入模块

int init_module(void) { //创建proc/myfile目录 example_dir = (struct proc_dir_enry *)proc_mkdir(PMDIR,NULL); if (example_dir == 0){ printk (\ return -1; } data_file = (struct proc_dir_entry *)create_proc_entry(PMFILE,0666,example_dir); if (data_file == 0){ remove_proc_entry(PMFILE,0); printk(\ return -ENOMEM; } strcpy(mydata.value,\ data_file->data = &mydata; data_file->read_proc = &proc_read; data_file->write_proc=&proc_write; //data_file->owner=THIS_MODULE; 在我的内核中该结构已经没有owner成员了 return 0; }

//卸载模块

void cleanup_module(void) { remove_proc_entry(PMFILE,example_dir); remove_proc_entry(PMDIR,NULL); printk(\}

MODULE_LICENSE(\

MODULE_DESCRIPTION(\MODULE_AUTHOR(\

参考材料 lke2012.pdf

本文来源：https://www.bwwdw.com/article/gta6.html