一个模块引用另一个模块导出的函数

最新推荐文章于 2022-10-21 17:09:27 发布

真胖子

最新推荐文章于 2022-10-21 17:09:27 发布

阅读量2.7k

点赞数 2

分类专栏： li nu x内核模块文章标签： linux 源代码实例内核

本文链接：https://blog.csdn.net/figtingforlove/article/details/20067463

版权

li nu x内核模块专栏收录该内容

5 篇文章 0 订阅

订阅专栏

/本篇由真胖子同志打造，原创辛苦，转载请标明出处http://blog.csdn.net/figtingforlove/article/details/20067463 /

编写一个内核模块，在模块中引用另一个模块的导出函数。
编写提供plus导出函数的module_plus模块

（1）源程序

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

MODULE_LICENSE("GPL");

static int init(void)
{
	printk("<0>""\nplus_init success!\n");
	return 0;
}

static int exit(void)
{
	printk("<0>""\nplus_exit success!\n");
	return0;
}

int plus(int a, int b)
{
    return(a+b);
}

EXPORT_SYMBOL(plus);
module_init(init);
module_exit(exit);

(2）Makefile文件

ifneq ($(KERNELRELEASE),)
    obj-m :=module_plus.o
else
    KERNELDIR := /lib/modules/$(shell uname -r)/build
    PWD := $(shell pwd)
default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

endif

Makefile编写的具体格式以后分析~~~~~~
（3）编译,加载，查看输出
make
sudoinsmod module_plus.ko
dmesg后可以看到终端显示“plus_initsuccess!”
lsmod可以看到如下显示，表明模块加载成功了
Module Size Used by
module_plus 12630 0
cat /proc/kallsyms查看内核符号表可以看到模块导出的函数
0000000000000000T plus [module_plus]
现在已经有了一个模块module_plus提供了一个导出函数，在编写另一个模块之前我们先看一下该模块的构成。
上述make编译在模块的目录下生成了几个重要的文件，看看他们都表示什么

module_plus.mod.c文件，也就是前面所说的由模块编译工具链生成的，在来看看那个有趣的声明

struct module __this_module
__attribute__((section(".gnu.linkonce.this_module"))) = {
	.name = KBUILD_MODNAME,
	.init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
	.exit = cleanup_module,
#endif
	.arch = MODULE_ARCH_INIT,
};

此外它还提供了模块的版本信息和依赖关系.
Module.symvers文件提供了模块导出的函数信息，包括函数地址，函数名，所在模块目录
0x668f06c7 plus /home/l/ll/otn项目/项目测试代码/内核模块实例/模块符号导出实例/symbol/module_plus EXPORT_SYMBOL
编写module_test模块，引用plus函数，按照一般程序设计代码如下

（1）源程序

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

MODULE_LICENSE("GPL");

extern int plus(int,int);
static int hello_init()
{
	printk(KERN_ALERT"Hello world\n");
	inti ;
	int c = 0;

	c = plus(1,2);
	printk(KERN_ALERT"c = %d\n",c);
	return0;
}

static int hello_exit()
{
	printk(KERN_ALERT"Goodbye world\n");
	return0;
}
module_init(hello_init);
module_exit(hello_exit);

（2）编译make，可以看到一个警告说“plus”函数未定义
WARNING:"plus"[/home/l/ll/otn项目/项目测试代码/内核模块实例/模块符号导出实例/hello/hello.ko]undefined!
（3）加载sudoinsmod hello.ko
insmod:error inserting 'hello.ko': -1 Invalid parameters
说是有不可用的参数，why？看看输出信息dmesg
[2052.726996] hello: no symbol version for plus
[2052.727001] hello: Unknown symbol plus (err -22)
原来是找不到“plus”符号，奇怪ing，明明已经导出了啊，why？
。。。。。这时候想到刚才module_plus模块加载后查看内核符号表似的输出
cat /proc/kallsyms查看内核符号表可以看到模块导出的函数
0000000000000000T plus [module_plus]
奇怪的00000000000,也就是说内核符号表中该函数的地址竟然是0,也就是未知，难怪加载模块的时候找不到对应的函数代码。So？How?
Answer1 :想到module_plus模块不是生成了Mododule.symvers符号视图么，那么用这个文件替换当前hello模块目录下生成的Mododule.symvers文件
编译，success
加载，success
dmesg,[ 2278.175896] c = 3
好吧，他成功了，butwhy？
发挥伟大的大脑~~~~~~回顾一下前面的模块加载部分，在发现“为解决的引用”符号时，的处理函数
Answer2：既然内核符号表导出函数地址是0,而函数确实导出了，那我们就找到这个有加载的Module_plus模块中plus函数的地址

内核编程中关于查找导出符号的函数，具体的函数解释请看导出符号章节。

/*inclede/module.h*/

/*Find a symbol and return it, along with, (optional) crc and(optional) module which owns it */

const struct kernel_symbol *find_symbol(const char *name,struct module **owner,const unsigned long **crc,bool gplok,bool warn)
{
	struct find_symbol_arg fsa;
	fsa.name= name;
	fsa.gplok= gplok;
	fsa.warn= warn;

	if(each_symbol(find_symbol_in_section, &fsa)) {
		if(owner)
			*owner= fsa.owner;
		if(crc)
			*crc= fsa.crc;
		return fsa.sym;
	}

	DEBUGP("Failedto find symbol %s\n", name);
	return NULL;
}
EXPORT_SYMBOL(find_symbol);

//得到符号表的函数符号地址
void*__symbol_get(const char *symbol)
{
	struct module *owner;
	const struct kernel_symbol *sym;
	preempt_disable();
	sym= find_symbol(symbol, &owner, NULL, true, true);
	if(sym && strong_try_module_get(owner))
		sym= NULL;
	preempt_enable();
	return sym ? (void *)sym->value : NULL;
}

EXPORT_SYMBOL(__symbol_get);

修改上述程序代码如下,我们用__symbol_get获取函数指针：

typedef int (*plus)(int a, int b);
//extern int plus(int,int);
static int hello_init()
{
	printk(KERN_ALERT"Hello world\n");
	plus p = NULL;
	inti ;
	
	p= (plus)__symbol_get("plus") ;
	int c = 0;
	//c= plus(1,2);
	c = p(1,2);
	printk(KERN_ALERT"c = %d\n",c);
	return 0;
}

make，insmod,dmesg没有任何问题，问题解决，看来该方法可行。
[14534.773267]plus_init success!
[14681.389583]Hello world
[14681.389592]c = 3
总结一下，看来模块加载的时候会在处理引用的符号时根据依赖关系搜索该符号，得到所引用函数的地址。
在不做处理时，hello模块加载无法找到plus函数，不能建立模块间的依赖关系。hello.mod.c文件中

static const char __module_depends[]__used
__attribute__((section(".modinfo")))=
"depends=";
answer1:模块在加载的时候，根据Module.symvers文件，知道会用到那个导出的引用，并且得到模块module_plus
static const char __module_depends[]
__used__attribute__((section(".modinfo")))=
"depends=mosule_plus";
answer2 :在模块加载的时候，根据内核导出模块处理“为解决引用”符号的原则，找到到处符号表，重定位，找到符号地址~~find_symbol
大概就是这样，也许有误差，但不影响理解。But，如果此时卸载模块module_plusrmmodmodule_plus会提示ERROR:Module module_plus is inuse，我们已经卸载了引用它的模块了，为什么还卸载不了？那我们就再编写一个模块去读module_plus模块的状态，看看为什么。

(3)编写测试模块读另一个模块的状态

#include<linux/init.h>
#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/list.h>
#include<linux/cpumask.h>
static int __init mymod_init(void)
{
	struct module *mod;
	struct module_use *use;
	int cpu;
	//打印本模块的模块名和模块状态
	printk(KERN_ALERT"[insmod mymod] name:%s, state:%d\n",THIS_MODULE->name,THIS_MODULE->state);
	//遍历模块列表，查找target模块
	list_for_each_entry(mod,THIS_MODULE->list.prev,list)
	{
		if(strcmp(mod->name,"module_plus")==0){
			//1.打印模块的模块名、模块状态、引用计数
			printk(KERN_ALERT"name:%s,state:%d, refcnt:%lu ",mod->name,mod->state,module_refcount(mod));
			//1.打印出所有依赖module_plus的模块名（遍历mod->source_list)
			if(!list_empty(&mod->source_list)){
				list_for_each_entry(use,&mod->source_list,source_list)
				printk(KERN_ALERT"%s\t",use->source->name);
			}else
				printk(KERN_ALERT"used by NULL\n");
			/*
			//2.将模块的引用计数变为0
			for_each_possible_cpu(cpu){
				per_cpu_ptr(mod->refptr, cpu)->decs = 0;
				per_cpu_ptr(mod->refptr,cpu)->incs = 0;
			}
			//2.再看看module_plus的名称、状态、引用计数
			printk(KERN_ALERT"name:%s,state:%d, refcnt:%lu\n",mod->name,mod->state,module_refcount(mod));
			*/
		}
	}
	return 0;
	}

static int __exit mymod_exit(void)
{
	printk(KERN_ALERT"[rmmodmymod] name:%s state:%d\n",THIS_MODULE->name,THIS_MODULE->state);
	return0;
}

module_init(mymod_init);
module_exit(mymod_exit);
MODULE_AUTHOR("lilei");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Whymodule can not be removed");

先来分下下代码

/*linux/module.h*/
/*模块状态*/
208 enum module_state {
209 	MODULE_STATE_LIVE, // 0
210 	MODULE_STATE_COMING, // 1
211 	MODULE_STATE_GOING, // 2
212 	MODULE_STATE_UNFORMED, // 3
213};

/*模块引用计数*/

224 struct module_ref {
225 	unsigned long incs;
226 	unsigned long decs;
227} __attribute((aligned(2 * sizeof(unsigned long))));
228

/*kernel/module.c*/
/*获取模块的引用计数函数*/

774 unsigned long module_refcount(struct module *mod)
775{
776 	unsigned long incs = 0, decs = 0;
777 	int cpu;
778
779 	for_each_possible_cpu(cpu)
780 		decs += per_cpu_ptr(mod->refptr, cpu)->decs;
794 	smp_rmb();
795 	for_each_possible_cpu(cpu)
796 		incs += per_cpu_ptr(mod->refptr, cpu)->incs;
797 	return incs - decs;
798}

现在对代码1编译，加载模块，dmesg
[8276.079311] [insmod mymod] name:a, state:1
[8276.079317] name:module_plus, state:0,refcnt:1
[8276.079318] used by NULL
这里stat：1表示mod->state= MODULE_STATE_COMING,说明这个模块正在执行mod->init函数，还没有执行到mod->state= MODULE_STATE_LIVING。可以看到module_plusde的引用计数是1。简单的想，是不是把这个模块的这个值变为0,就可以了？试试吧，去掉注释把代码2加进来,老过程。。。
[8276.079311] [insmod mymod] name:a, state:1
[8276.079317] name:module_plus, state:0, refcnt:1
[8276.079318] used by NULL
[8276.079321] name:module_plus, state:0,refcnt:0
[8307.155957]
[8307.155957] plus_exit success!
[8358.543440] [rmmod mymod] name:a state:2
模块是成功卸载了，但是为什么？

可以看到，虽然这时的module_plus并没有其它模块依赖它了但refcnt=1。why？很容易想到是我们在hello模块中添加的代码有bug，应该是在某个地方将模块计数加1了。我们在编写module_plus的时候，通过调用__symbol_get查找符号

1886 void *__symbol_get(const char *symbol)
1887{
1888 	struct module *owner;
1889 	const struct kernel_symbol *sym;
1890
1891 	preempt_disable();
1892 	sym = find_symbol(symbol, &owner, NULL, true, true);
1893 	if (sym && strong_try_module_get(owner))
1894 		sym = NULL;
1895 	preempt_enable();
1896
1897 	return sym ? (void *)sym->value : NULL;
1898}

/*查看源代码find_symbol没有问题，再看看strong_try_module_get*/

190 static inline int strong_try_module_get(struct module *mod)
191{
192 	BUG_ON(mod && mod->state ==MODULE_STATE_UNFORMED);
193  	if (mod && mod->state == MODULE_STATE_COMING)
194  		return -EBUSY;
195 	if (try_module_get(mod))
196 		return 0;
197 	else
198 	return -ENOENT;
199}

/*再看try_module_get*/

951 bool try_module_get(struct module *module)
952{
953 	bool ret = true;
954
955 	if (module) {
956 		preempt_disable();
957
958 		if (likely(module_is_live(module))) {
959 			__this_cpu_inc(module->refptr->incs);
960 			trace_module_get(module, _RET_IP_);
961 		} else
962 			ret = false;
963
964 		preempt_enable();
965 	}
966 	return ret;
967}

惊喜的发现果然__this_cpu_inc(module->refptr->incs);对模块的引用计数加了1,不出所料（尼玛的不出，找了好久，才想到~。。~）这就是为什么refcnt=1了，怪不得不能卸载模块，所以说内核代码也不能随便引用，特别是在不了解他的细节的时候。现在了解了原因，那我们换个函数find_symbol试试。因为直接更改模块的这个变量值总觉得不是很规范。

static int hello_init()
{
	printk(KERN_ALERT"Hello world\n");
	plus p = NULL;
	const struct kernel_symbol *sym;;
	int c = 0;

	sym = find_symbol("plus",THIS_MODULE, NULL, true, true);
	if(sym) {
		p= (plus*)sym->value;
		c= p(1,2);
	}else
	sym= NULL;
	p= NULL;
	printk(KERN_ALERT"c = %d\n",c);
	return 0;
}

编译，加载，dmesg
[14534.773267]plus_init success!
[14681.389583]Hello world
[14681.389592]c = 3
ok!noproblem ~~~正常卸载了，至于符合规范这回事，我也不知道，可这也算是一种方法吧。
2.6内核的解决~~请参考
http://blog.csdn.net/zhangskd/article/details/7945140

真胖子

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
一个模块引用另一个模块导出的函数

编写一个内核模块，在模块中引用另一个模块的导出函数。编写提供plus导出函数的module_plus模块（1）源程序#include#include#includeMODULE_LICENSE("GPL");staticint init(void){printk("""\nplus_init success!\n");return 0;}stat
复制链接

扫一扫