文档章节

内核模块编写

陈洪波
 陈洪波
发布于 2015/05/19 19:32
字数 1851
阅读 33
收藏 2

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

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/ (shellunamer)/buildM= (shell pwd) modules
clean:
make -C /lib/modules/ (shellunamer)/buildM= (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, /*读出数据结构在page中的偏量*/
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文件中.

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

本文转载自:http://blog.csdn.net/hongbochen1223/article/details/45746783

陈洪波
粉丝 2
博文 76
码字总数 1552
作品 0
济南
程序员
私信 提问
linux驱动(一):linux驱动框架

编写linux驱动先看一下驱动框架是什么样子的。 驱动编写和应用层编写有什么区别呢? (一)首先 入口函数的问题。应用层编写我们的入口就是main函数,但在驱动编写时不是这样的,有两种情况,...

u012142460
2017/12/23
0
0
Linux 字符设备驱动例子

编写好驱动,通过挂载的方法将驱动程序挂载到内核里面,大致步骤如下: 一: 1>建立以.c为后缀的c语言程序文件 (里面包含了设备名及设备号等) 2>建立Makefile文件(作用是通过make来产生设备文件*...

满小茂
2016/05/23
256
0
如何编写简单的linux内核模块

摘要:尽管Linux系统为应用程序提供了强大而丰富的API,但是有的时候,这些还远远不够。当我们需要与硬件进行交互,或者需要访问系统中特权信息的时候,应用API就爱莫能助了,这时我们必须借...

嘶吼
2017/12/12
0
0
Linux设备驱动开发学习(3):构造和运行模块

从本章开始引入所有关于模块和内核编程的基本概念,并编写一个完整模块来实践这些基本的概 念。 3.1 搭建测试环境 由于所有测测试代码都是基于Ubuntu 14.04.2 Desktop的3.16.0-30-generic内核...

lengxujun
2016/06/20
0
0
Linux Kernel Module 的实现过程

【1】有必要查询下Linux内核 # uname -r2.6.28-11-generic ls /usr/src/ linux-headers-2.6.28-11 linux-headers-2.6.28-11-generic 由此可见内核版本和内核头文件版本是一致的,都是2.6.28-...

wangxigui
2012/11/13
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Tedis:基于 TiKV 构建的 NoSQL 数据库

作者介绍: 陈东明,饿了么北京技术中心架构组负责人,负责饿了么的产品线架构设计以及饿了么基础架构研发工作。曾任百度架构师,负责百度即时通讯产品的架构设计。具有丰富的大规模系统构 ...

TiDB
34分钟前
0
0
linux命令

ls命令是linux下最常用的命令。ls命令就是list的缩写,缺省下ls用来打印出当前目录的清单。如果ls指定其他目录,那么就会显示指定目录里的文件及文件夹清单。 通过ls 命令不仅可以查看linux文件...

WinkJie
41分钟前
1
0
你需要的物流运输类报表,这里都有

你需要的物流运输类报表,都在这里 葡萄城报表模板库是一款免费的报表制作、学习和参考工具,包含了超过 200 张高质量报表模板,涵盖了 16 大行业和 50 多种报表类型,为 30 余万报表开发者提...

葡萄城技术团队
48分钟前
3
0
像Java SE一样编写Java EE(ddd探索)

今天主要改写昨天的组合模式成Web系统。 容器接口为 public interface TreeProduct { /** * 展示所有产品 * @return */ List<TreeProduct> allProducts();...

算法之名
49分钟前
0
0
Django Model 模型建立

Django Model 模型 Django Model层是Django的数据模型层,每一个Model类就是数据库中的一张表; 我们需要注意下面几点: model一般都是定义在不同的APP的models.py模块文件中,可以是一个,也...

彩色泡泡糖
58分钟前
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部