内核模块编写

* 内核动态模块的的功能和作用*

Linux 模块是一些可以独立于内核单独编译的内核函数和数据类型集合,是可增删的内核部分。模块在内核启动时装载称为静态装载,在内核已经运行时装载称为动态装载。模块可以扩充内核所期望的任何功能,但通常用于实现设备驱动程序.

模块最基本的框架

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>

static ini __init 模块名_init(void)
{
/*
* 安装模块的初始化工作 ??
*/
return 0;
}

Static void __exit 模块名_exit(void)
{
/*
* 卸载模块前的清理工作 ??
*/
}

module_init(模块名_init);
module_exit(模块名_exit);

动态模块的编译

Makefile 文件的约定
预定义的宏:
obj-m := 模块名.o
预定义的命令:
make –C 内核源代码的安装路径 M=动态模块源代码路径 modules
将生成动态安装的模块文件:模块名.ko
例如:
obj-m := hello.o
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
如果有多个目标模块:
obj-m := hello.o
hello-objs := a.o b.o

与动态模块有关的 Shell 命令

列出已安装的动态模块名:
lsmod
安装一个动态模块:
insmod 模块名.ko
卸载一个动态模块:
rmmod 模块名.ko
安装依赖模块:
modprobe
显示模块信息:
modinfo 模块名.ko

模块安装时携带的可选参数

#include <linux/moduleparam.h>
module_param(变量名,类型,权限)
支持的类型:
Byte.short,ushort,int,uint,long,ulong,bool,charp
例如在 hello.c 中加入:
#include <linux/moduleparam.h>
static int test;
module_param(test,int,0644);
用法 :
insmod hello.ko test=10

许可和文档有关的宏

MODULE_LICENSE(“GPL”);
MODULE_DESCRIPTION(“xxxxxxxx”);
MODULE_AUTHOR(“xxxxxxx”);

在模块中使用内核的/proc 接口

//建立一个 proc 目录文件:
struct proc_dir_entry *proc_mkdir(const char *,
    /*要创建的 proc 目录名*/
    struct proc_dir_entry *
    /*上级目录,NULL 代表/proc*/
);

//建立一个 proc 普通文件:
struct proc_dir_entry *create_proc_entry(const char *name,
/*要创建的 proc 文件名*/
mode_t mode,
/*proc 文件的权限*/
struct proc_dir_entry *parent/*上级目录,NULL 代表/proc*/
);

//删除一个 proc 文件:
void remove_proc_entry(const char *name, /*要删除的 proc 文件名*/
struct proc_dir_entry *parent /*上级目录,NULL 代表/proc*/
);

//proc 入口数据结构:
struct proc_dir_entry {
unsigned int low_ino;
/*目录入口的 inod 节点号*/
unsigned short namelen;
/*节点名长度*/
const char *name;
/*节点名*/
mode_t mode;
/*节点类型和权限*/
nlink_t nlink;
/*节点的连接数*/
uid_t uid;
/*拥有该节点的用户 uid*/
gid_t gid;
/*拥有该节点的组 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=指向你的写操作处理函数(自己定义)

//读写操作函数的参数:
int (read_proc_t)(char *page,
/*存读出数据的地址*/

char **start, /*内核中不用*/
off_t off, /*读出数据结构在ｐａｇｅ中的偏量*/
int count, /*读出数据字节数*/
int *eof, /*文件尾标志*/
void *data); /*文件数据的地址*/

int (write_proc_t)(struct file *file,
/*通常不用*/
const char __user *buffer, /* 用 户 空 间 数 据 地 址 , 需 要 用
copy_from_user 写入*/
unsigned long count,
/*从用户空间写入的数据长度*/
void *data);
/*写入文件的地址*/

下面我们编辑一个Hello World模块

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

int init_module(void){
    printk("Hello Module!!\n");
    return 0;
}

void cleanup_module(void){
    printk("bye module!!\n");
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Hello World!!");
MODULE_AUTHOR("bobo");

其中的Makefile文件为:

obj-m := hello.o

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

我们使用make命令进行编译,编译之后的结果是在目录中形成下面的文件:

下面我们将terminal终端的操作目录切换到当前目录下,动态加载该模块:

sudo insmod hello.ko

我们使用dmesg命令查看内核模块内容的输出:

dmesg

下面是我的模块的输出结果:

现在我们使用卸载模块的命令进行卸载:

sudo rmmod hello

模块输出信息为:

这是一个最简单的内核模块.

下面我们使用内核模块来创建proc文件,并向文件中写入内容.下面是我的程序的实现:

/********************************************
  编写创建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>

#define MODULE_NAME "Myproc"
#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 *date_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;
    len += sprintf(page,"%s%ld\n",mydatap->value,jiffies);

    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)){
        return -EFAULT;
    }

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

    return len;
}


//装入模块
int init_module(void){

    //创建/proc/myfile目录
    example_dir = (struct proc_dir_entry *)proc_mkdir("mydir",0);

    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,"Ticks=");
    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("bobo");

其中,Makefile文件为:

obj-m := mod.o
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

同样的道理编译完成之后,我们使用insmod命令将文件加载到内核中,我们查看/proc目录下是否有我们创建的mydir文件夹,并且该文件夹下面存在一个名为myfile的文件,同时我们查看其中的内容.

下面我们编写一个用户空间程序,来测试用户读取/proc/mydir/myfile文件所用的时间,我们使用的是系统提供的gettimeofday函数.

其中gettimeofday()函数有两个参数:

int gettimeofday(struct timeval *tv,struct timezone *tz);

其中的数据结构timeval为:

struct timeval{
    long int tv_sec; //秒数
    long int tv_usec; //毫秒
};

数据结构timezone为时区,如果不用就设置为NULL

下面是我的用户测试程序:

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

#define path "/proc/mydir/myfile"

//字符串的长度
#define LEN 16

//读取之前的时间
struct timeval tv_begin;

//读取之后的时间
struct timeval tv_end;

//存储读出的字符串的长度
char buf[LEN];

int main()
{

    FILE *fp;

    gettimeofday(&tv_begin,NULL);
    fp = fopen(path,"r");
    printf("%s\n",fgets(buf,LEN,fp));
    gettimeofday(&tv_end,NULL);

    printf("used %d s %d us\n",tv_end.tv_sec-tv_begin.tv_sec,tv_end.tv_usec-tv_begin.tv_usec);

    return 0;
}

我们使用命令:

gcc test.c -o test

编译之后,运行

./test

其运行结果为:

下面一篇博客我将使用内核模块从当前进程开始,向前遍历,一直遍历到初始进程,将其信息保存到proc文件中.

## 未完待续!!!!##