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文件的时候得到的结果都不一样

      遍历父进程：

     

   遍历所有进程，通过for_each_process(task)这个宏来遍历所有进程：

    实验C：

在模块开头通过module_param声明了模块参数，在装载模块时通过它来传参

在proc_read函数中通过这个传入的参数来判断应该读取内核的哪些数值，其中标注黄色的一段是从内核实现/proc/loadavg部分中抽取出来的，loops_per_jiffy是每个滴答能执行的循环数，在内核启动的时候计算出来的这个值：

在这里我们还设计了改写loops_per_jiffy的方法：

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

程序完整源代码：

问题A：

问题A用户测试程序：

问题B：

问题C：

参考材料

lke2012.pdf

 

第二篇：Linux 内核编程实验报告4

Linux内核分析实验报告

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

实验目的：学习模块，模块式linux特有的一种机制。模块可以动态地增加内核的功能。编写模块，将它作为linux内核空间的扩展。

硬件环境：内存1G以上

软件环境：Linux（Ubuntu） 2-6

实验步骤：

一：实验原理简介：

 模块一旦被转载进系统，就会在系统态下运行。如果模块知道系统的数据结构地址，就可以读写相应的数据结构。模块作为一种抽象的数据类型，他有一个可以通过静态内核中断的接口。加入模块的每个新函数必须在该模块被装载到内核时进行注册。如果模块式静态装载的，加入模块的所有函数在内核启动时候进行注册。如果是动态装载的，必须在装载这个模块时候动态注册。注册工作在init_module() 中完成，注销工作是在cheanup_module()中完成。

对于模块的使用有两种方式。一种是设备驱动程序，一种是/proc文件。

本实验中要求从当前进程开始，首先追溯到init进程，显示出一路上经历的所有进程的进程号，进程名。然后从init进程开始，遍历所有的进程，显示进程名与进程号。前者主要是用到一个while循环，判断当前进程进程号是否是1，后者主要是用到一个宏定义for_each_process，遍历所有的进程。

二：主要数据结构：

   1./proc下的文件（目录）结构：

struct proc_dir_entry {

    unsigned int low_ino;             /*目录入口的imod节点号 */

    unsigned short namelen;          /*节点名长度*/

    const char *name;                /*节点名*/

    mode_t mode;                     /*节点的类型和权限*/

    nlink_t nlink;                   /*节点的连接数*/

    uid_t uid;                       /*拥有该节点的用户uid*/

    gid_t gid;                      /*g拥有该节点的组gid*/

    loff_t size;             

/*节点的限制大小，除非限制长度，否则为 0*/

    struct inode_operations * proc_iops;     

/*对该节点的操作*/

    const struct file_operations * proc_fops;  

 /*对该文件的操作*/

    get_info_t *get_info;      /*如果定义，当有读操作时候调用*/

    struct module *owner;      /*拥有该模块的用户*/

struct proc_dir_entry *next, *parent, *subdir;

/*节点间的关系，初始为NULL*/

    void *data;                 /*节点对应文件的内容*/

    read_proc_t *read_proc;           /*读操作函数*/

    write_proc_t *write_proc;          /*写操作函数*/

    atomic_t count;                    /* 节点引用计数 */

    int deleted;                        /* 节点删除标志 */

    void *set;

  };

其中几个属性的设置为：

owner=THIS_MODULE;

data 指向文件数据区，自己定义

read_proc 指向读操作处理函数

write_proc 指向写操作处理函数

三：主要函数介绍

      1：系统函数

（1）init_module()

函数说明：系统调用装载模块

        （2）cleanup_module()

               函数说明：清除模块。

（3）int sprintf(string format, mixed [args]...)

       函数说明：将args各个函数的参数整合到format字符串中。

       四：程序流程：

               进程初始化过程当中，我们将进程的信息，整合到mydata数据结构当中，然后输出：

具体内容包括：

从当前进程开始向上遍历，直至进程号为1结束（81行—85行）：

用宏调用for_each_process从init开始逐个遍历进程，同样的方式将将进程的信息追加到mydata数据结构。（90行—95行）

(见图3--1)

      

                                （图3--1）

五：结果检测：

       编译模块：进入程序所在的目录，键入make命令

       安装模块：sudo install shiyan.ko

测试结果：lsmod

         显示结果是

  

正确，说明模块被正确加载

             进入/proc/mydir下查看myfile文件内容：

结果见图3--2

                     

         

                        （ 图3—2 ）

（正确）

 结论分析与体会：

       模块是系统中一个重要的组成部分，其中涉及到设备驱动的相关内容，本试验的内容相对比较简单，但是却为以后的实验，甚至将来的内核编程奠定的基础。

附：程序源代码

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

**

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

                           main.c   -   description

    begin                :  4   4 21:01:11 CST 20##

    copyright            : (C) 20## by  张鸿烈

    Function             : 编写创建proc文件系统的模块,该程序创建在/proc目录下

                         : 创建mydir目录, 在mydir目录下创建保存当前的系统时间 

                           jiffies值的文件 myfile,

                          

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

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/proc_fs.h>

#include <linux/jiffies.h>

#include <asm/uaccess.h>

#include <linux/moduleparam.h>

#include <linux/list.h>

#include <linux/sched.h>

#define MODULE_NAME "Myproc"

#define MYDATA_LEN  8192

// 放用户空间传入的数据

struct my_proc_data{

  char value[MYDATA_LEN];

};

struct my_proc_data mydata;  

struct task_struct *task;

int count;

static struct proc_dir_entry *example_dir;

static struct proc_dir_entry *date_file;

static int  param;

char temp[15];

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;

   

   len+=sprintf(page,"%s%ld\n",mydatap->value,jiffies); //将字符串格式化    //可以直接使用内核变量

   return len;  

} 

//写文件myfile的写驱动函数 ,把mydata的数值写到文件中

static int proc_write(struct file *file,const char *buffer,unsigned long count,void *data){ //file直接就是myfile?buffer指向的是用户空间的什么数据？

   int len ; 

   struct my_proc_data *mydatap = (struct my_proc_data *) data;

   if(count>MYDATA_LEN)

      len = MYDATA_LEN;

   else 

      len = count; //长度最大是16

   if(copy_from_user(mydatap->value,buffer,len)){ //把buffer(用户空间)中的数据写道mapdatap(内核空间)的data结构中去

      return -EFAULT;

   }

   //数据已经存在mydata结构当中了

   mydatap->value[len-1] = '\0';

   return len;  

}   

// 装入模块

int init_module(void)

{

    example_dir = (struct proc_dir_entry * )proc_mkdir("mydir",0); //在/proc目录下建立

   if(example_dir == 0)

   {

       printk("mkdir fail\n");

       return -1;

    }

   //创建/proc/mydir/myfile文件

    date_file=(struct proc_dir_entry *)create_proc_entry("myfile",0666,example_dir);

    if(date_file == 0)

    {

       remove_proc_entry("myfile",0);

       printk("mkfile fail\n");

       return -ENOMEM;

    }

  

    strcpy(mydata.value,"逐层遍历父进程：\n");

    sprintf(mydata.value,"%s %d %s-->\n",mydata.value,current->pid,current->comm);

    task=NULL;

    task=current;

    // 从初始进程开始向上遍历

    while(task->pid!=1)//

    {

      task=task->parent;

      sprintf(mydata.value,"%s %d %s-->\n",mydata.value,task->pid,task->comm);

    }

   task=&init_task;

        count=0; 

   printk("当前的进程是………………………………………………………………………… %d %s\n",current->pid,current->comm);

   sprintf(mydata.value,"%s %s \n",mydata.value,"当前所有的任务是");

   for_each_process(task)

   {

       count++;

        sprintf(mydata.value,"%s %d %s\n",mydata.value,task->pid,task->comm);

            printk(" %d %s\n",task->pid,task->comm);

    }  

   

    date_file->data=&mydata;

    date_file->read_proc=&proc_read;//参数在哪里传递？

    date_file->write_proc=&proc_write;

    date_file->owner=THIS_MODULE;

    return 0;

}

//卸载模块

void cleanup_module(void)

{

  remove_proc_entry("myfile",example_dir);

  remove_proc_entry("mydir",NULL);

  printk("Goodbye.\n");

 

}

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Test");

MODULE_AUTHOR("xxx");