内核模块编写
* 内核动态模块的的功能和作用*
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/
clean:
make -C /lib/modules/
如果有多个目标模块:
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文件中.
浙公网安备 33010602011771号