那么如何将驱动直接编译进内核呢？
在我们实际内核的移植配置过程中经常听说的内核裁剪又是怎么麽回事呢？
我们在进行linux内核配置的时候经常会执行make menuconfig这个命令，然后屏幕上会出现以下界面：
这个界面是怎么生成的呢？
跟我们经常说的内核配置与与编译又有什么关系呢？
下面我们借此来讲解一下linux内核的配置机制及其编译过程。
Linux内核的配置系统由三个部分组成，分别是：
1、Makefile：分布在 Linux 内核源代码根目录及各层目录中，定义 Linux 内核的编译规则；
2、配置文件（config.in(2.4内核，2.6内核)）：给用户提供配置选择的功能；
3、配置工具：包括配置命令解释器（对配置脚本中使用的配置命令进行解释）和配置用户界面（提供基于字符界面、基于 Ncurses 图形界面以及基于 Xwindows 图形界面的用户配置界面，各自对应于 Make config、Make menuconfig 和 make xconfig）。
这些配置工具都是使用脚本语言，如 Tcl/TK、Perl 编写的（也包含一些用 C 编写的代码）。本文并不是对配置系统本身进行分析，而是介绍如何使用配置系统。所以，除非是配置系统的维护者，一般的内核开发者无须了解它们的原理，只需要知道如何编写 Makefile 和配置文件就可以。
二、makefile menuconfig过程讲解
当我们在执行make menuconfig这个命令时，系统到底帮我们做了哪些工作呢？
这里面一共涉及到了一下几个文件我们来一一讲解
Linux内核根目录下的scripts文件夹
arch/$ARCH/Kconfig文件、各层目录下的Kconfig文件
Linux内核根目录下的makefile文件、各层目录下的makefile文件
Linux内核根目录下的的.config文件、arm/$ARCH/下的config文件
Linux内核根目录下的 include/generated/autoconf.h文件
1）scripts文件夹存放的是跟make menuconfig配置界面的图形绘制相关的文件，我们作为使用者无需关心这个文件夹的内容
2）当我们执行make menuconfig命令出现上述蓝色配置界面以前，系统帮我们做了以下工作：
首先系统会读取arch/$ARCH/目录下的Kconfig文件生成整个配置界面选项（Kconfig是整个linux配置机制的核心），那么ARCH环境变量的值等于多少呢？
它是由linux内核根目录下的makefile文件决定的，在makefile下有此环境变量的定义：
或者通过 make ARCH=arm menuconfig命令来生成配置界面，默认生成的界面是所有参数都是没有值的
比如教务处进行考试，考试科数可能有外语、语文、数学等科，这里相当于我们选择了arm科可进行考试，系统就会读取arm/arm/kconfig文件生成配置选项（选择了arm科的卷子），系统还提供了x86科、milps科等10几门功课的考试题
3）假设教务处比较“仁慈”，为了怕某些同学做不错试题，还给我们准备了一份参考答案（默认配置选项），存放在arch/$ARCH/configs下，对于arm科来说就是arch/arm/configs文件夹：
此文件夹中有许多选项，系统会读取哪个呢？内核默认会读取linux内核根目录下.config文件作为内核的默认选项（试题的参考答案），我们一般会根据开发板的类型从中选取一个与我们开发板最接近的系列到Linux内核根目录下（选择一个最接近的参考答案）
#cp arch/arm/configs/s3c2410_defconfig .config
4).config
假设教务处留了一个心眼，他提供的参考答案并不完全正确（.config文件与我们的板子并不是完全匹配），这时我们可以选择直接修改.config文件然后执行make menuconfig命令读取新的选项
但是一般我们不采取这个方案，我们选择在配置界面中通过空格、esc、回车选择某些选项选中或者不选中，最后保存退出的时候，Linux内核会把新的选项（正确的参考答案）更新到.config中，此时我们可以把.config重命名为其它文件保存起来（当你执行make distclean时系统会把.config文件删除），以后我们再配置内核时就不需要再去arch/arm/configs下考取相应的文件了，省去了重新配置的麻烦，直接将保存的.config文件复制为.config即可.
5）经过以上两步，我们可以正确的读取、配置我们需要的界面了
那么他们如何跟makefile文件建立编译关系呢？
当你保存make menuconfig选项时，系统会除了会自动更新.config外，还会将所有的选项以宏的形式保存在
Linux内核根目录下的 include/generated/autoconf.h文件下
内核中的源代码就都会包含以上.h文件，跟宏的定义情况进行条件编译。
当我们需要对一个文件整体选择如是否编译时，还需要修改对应的makefile文件，例如：
我们选择是否要编译s3c2410_ts.c这个文件时，makefile会根据CONFIG_TOUCHSCREEN_S3C2410来决定是编译此文件，此宏是在Kconfig文件中定义，当我们配置完成后，会出现在.config及autconf中，至此，我们就完成了整个linux内核的编译过程。
最后我们会发现，整个linux内核配置过程中，留给用户的接口其实只有各层Kconfig、makefile文件以及对应的源文件。
比如我们如果想要给内核增加一个功能，并且通过make menuconfig控制其声称过程
首先需要做的工作是：修改对应目录下的Kconfig文件，按照Kconfig语法增加对应的选项；
其次执行make menuconfig选择编译进内核或者不编译进内核，或者编译为模块，.config文件和autoconf.h文件会自动生成；
最后修改对应目录下的makefile文件完成编译选项的添加；
最后的最后执行make zImage命令进行编译。
三、具体实例
下面我们以前面做过的模块实验为例，讲解如何通过make menuconfig机制将前面单独编译的模块编译进内核或编译为模块
假设我已经有了这么一个驱动：
modules.c
[cpp] view plain copy print ?
#include <linux/module.h> /*module_init()*/
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
#define DEBUG //open debug message
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg)
#else
#define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
#endif
/* Module Init & Exit function */
static int __init myModule_init(void)
{
/* Module init code */
PRINTK("myModule_init\n");
return 0;
}
static void __exit myModule_exit(void)
{
/* Module exit code */
PRINTK("myModule_exit\n");
return;
}
module_init(myModule_init);
module_exit(myModule_exit);
MODULE_AUTHOR("dengwei"); /*模块作者，可选*/
MODULE_LICENSE("GPL"); /*模块许可证明，描述内核模块的许可权限，必须*/
MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/
#include <linux/module.h> /*module_init()*/ #include <linux/kernel.h> /* printk() */ #include <linux/init.h> /* __init __exit */ #define DEBUG //open debug message #ifdef DEBUG #define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg) #else #define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) #endif /* Module Init & Exit function */ static int __init myModule_init(void) { /* Module init code */ PRINTK("myModule_init\n"); return 0; } static void __exit myModule_exit(void) { /* Module exit code */ PRINTK("myModule_exit\n"); return; } module_init(myModule_init); module_exit(myModule_exit); MODULE_AUTHOR("dengwei"); /*模块作者，可选*/ MODULE_LICENSE("GPL"); /*模块许可证明，描述内核模块的许可权限，必须*/ MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/
Step1：将modules.c拷到drivers/char/目录下(这个文件夹一般存放常见的字符驱动)
Step2: vi driver/char/Kconfig,在
config DEVKMEM后添加以下信息
config MODULES
tristate "modules device support"
default y
help
Say Y here,the modules will be build in kernel.
Say M here,the modules willbe build to modules.
Say N here,there will be nothing to be do.
Step3：make menuconfig
Device driver-character devices
[*]modules device suppor
Step4:vi driver/char/Makefile，在js-rtc后添加
obj-$(CONFIG_MODULES)+= modules.o
CONFIG_MODULES 必须跟上面的Kconfig中保持一致，系统会自动添加CONFIG_前缀
modules.o必须跟你加入的.c文件名一致
最后执行：make zImage modules就会被编译进内核中
第三步：
Step3：make menuconfig
Device driver-character devices
[M]modules device suppor
把星号在配置界面通过空格改为M，最后执行make modules，在driver/char/目录下会生成一个modules.ko文件
跟我们前面讲的单独编译模块效果一样，也会生成一个模块，将它考入开发板执行insmod moudles.ko，即可将生成的模块插入内核使用
一、linux内核模块简介
linux内核整体结构非常庞大，其包含的组件也非常多。我们怎么把需要的部分都包含在内核中呢？
一种办法是把所有的需要的功能都编译到内核中。这会导致两个问题，一是生成的内核会很大，二是如果我们要在现有的内核中新增或删除功能，不得不重新编译内核，工作效率会非常的低，同时如果编译的模块不是很完善，很有可能会造成内核崩溃。
linux提供了另一种机制来解决这个问题，这种集中被称为模块，可以实现编译出的内核本身并不含有所有功能，而在这些功能需要被使用的时候，其对应的代码可以被动态的加载到内核中。
二、模块特点：
1）模块本身并不被编译入内核，从而控制了内核的大小。
2）模块一旦被加载，他就和内核中的其他部分完全一样。
注意：模块并不是驱动的必要形式：即：驱动不一定必须是模块，有些驱动是直接编译进内核的；同时模块也不全是驱动，例如我们写的一些很小的算法可以作为模块编译进内核，但它并不是驱动。就像烧饼不一定是圆的，圆的也不都是烧饼一样。
三、最简单的模块分析
1）以下是一个最简单的模块例子
[cpp] view plain copy print ?
#include <linux/init.h> /* printk() */
#include <linux/module.h> /* __init __exit */
static int __init hello_init(void) /*模块加载函数，通过insmod命令加载模块时，被自动执行*/
{
printk(KERN_INFO " Hello World enter\n");
return 0;
}
static void __exit hello_exit(void) /*模块卸载函数，当通过rmmod命令卸载时，会被自动执行*/
{
printk(KERN_INFO " Hello World exit\n ");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_AUTHOR("dengwei"); /*模块作者，可选*/
MODULE_LICENSE("Dual BSD/GPL"); /*模块许可证明，描述内核模块的许可权限，必须*/
MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/
MODULE_ALIAS("a simplest module"); /*模块说明，可选*/<span style="font-family:SimSun;font-size:18px;color:#FF0000;"><strong>
</strong></span>
#include <linux/init.h> /* printk() */ #include <linux/module.h> /* __init __exit */ static int __init hello_init(void) /*模块加载函数，通过insmod命令加载模块时，被自动执行*/ { printk(KERN_INFO " Hello World enter\n"); return 0; } static void __exit hello_exit(void) /*模块卸载函数，当通过rmmod命令卸载时，会被自动执行*/ { printk(KERN_INFO " Hello World exit\n "); } module_init(hello_init); module_exit(hello_exit); MODULE_AUTHOR("dengwei"); /*模块作者，可选*/ MODULE_LICENSE("Dual BSD/GPL"); /*模块许可证明，描述内核模块的许可权限，必须*/ MODULE_DESCRIPTION("A simple Hello World Module"); /*模块说明，可选*/ MODULE_ALIAS("a simplest module"); /*模块说明，可选*/<span style="font-family:SimSun;font-size:18px;color:#FF0000;"><strong> </strong></span>
2) 以下是编译上述模块所需的编写的makefile
[cpp] view plain copy print ?
obj-m :=hello.o //目标文件
#module-objs := file1.o file.o //当模块有多个文件组成时，添加本句
KDIR :=/usr/src/linux //内核路径，根据实际情况换成自己的内核路径，嵌入式的换成嵌入式，PC机的指定PC机路径
PWD := $(shell pwd) //模块源文件路径
all:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
@rm -rf *.mod.*
@rm -rf .*.cmd
@rm -rf *.o
@rm -rf Module.*
clean:
rm -rf *.ko
obj-m :=hello.o //目标文件 #module-objs := file1.o file.o //当模块有多个文件组成时，添加本句 KDIR :=/usr/src/linux //内核路径，根据实际情况换成自己的内核路径，嵌入式的换成嵌入式，PC机的指定PC机路径 PWD := $(shell pwd) //模块源文件路径 all: $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules @rm -rf *.mod.* @rm -rf .*.cmd @rm -rf *.o @rm -rf Module.* clean: rm -rf *.ko
最终会编译得到：hello.ko文件
使用insmodhello.ko将模块插入内核，然后使用dmesg即可看到输出提示信息。
常用的几种模块操作：
insmod XXX.ko 加载指定模块
lsmod 列举当前系统中的所有模块
rmmod XXX 卸载指定模块（注意没有.ko后缀）
dmesg 当打印等级低于默认输出等级时，采用此命令查看系统日志
3）linux内核模块的程序结构
1.模块加载函数：
Linux内核模块一般以__init标示声明，典型的模块加载函数的形式如下:
[cpp] view plain copy print ?
static int __init myModule_init(void)
{
/* Module init code */
PRINTK("myModule_init\n");
return 0;
}
module_init(myModule_init);
static int __init myModule_init(void) { /* Module init code */ PRINTK("myModule_init\n"); return 0; } module_init(myModule_init);
模块加载函数的名字可以随便取，但必须以“module_init(函数名)”的形式被指定；
执行insmod命令时被执行，用于初始化模块所必需资源，比如内存空间、硬件设备等；
它返回整形值，若初始化成功，应返回0，初始化失败返回负数。
2.模块卸载函数
典型的模块卸载函数形式如下：
[cpp] view plain copy print ?
static void __exit myModule_exit(void)
{
/* Module exit code */
PRINTK("myModule_exit\n");
return;
}
module_exit(myModule_exit);
static void __exit myModule_exit(void) { /* Module exit code */ PRINTK("myModule_exit\n"); return; } module_exit(myModule_exit);
模块卸载函数在模块卸载的时候执行，不返回任何值，需用”module_exit(函数名)”的形式被指定。
卸载模块完成与加载函数相反的功能：
若加载函数注册了XXX，则卸载函数应当注销XXX
若加载函数申请了内存空间，则卸载函数应当释放相应的内存空间
若加载函数申请了某些硬件资源（中断、DMA、I/0端口、I/O内存等），则卸载函数应当释放相应的硬件资源
若加载函数开启了硬件，则卸载函数应当关闭硬件。
其中__init 、__exit 为系统提供的两种宏，表示其所修饰的函数在调用完成后会自动回收内存，即内核认为这种函数只会被执行1次，然后他所占用的资源就会被释放。
3.模块声明与描述
在linux内核模块中，我们可以用MODULE_AUTHOR、MODULE_DESCRIPTION、MODULE_VERSION、MODULE_TABLE、MODULE_ALIA，分别描述模块的作者、描述、版本、设备表号、别名等。
[cpp] view plain copy print ?
MODULE_AUTHOR("dengwei");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("A simple Hello World Module");
MODULE_ALIAS("a simplest module");
MODULE_AUTHOR("dengwei"); MODULE_LICENSE("Dual BSD/GPL"); MODULE_DESCRIPTION("A simple Hello World Module"); MODULE_ALIAS("a simplest module");
四、有关模块的其它特性
1）模块参数：
我们可以利用module_param(参数名、参数类型、参数读写属性) 为模块定义一个参数，例如：
[cpp] view plain copy print ?
static char *string_test = “this is a test”;
static num_test = 1000;
module_param (num_test,int,S_IRUGO);
module_param (steing_test,charp,S_ITUGO);
static char *string_test = “this is a test”; static num_test = 1000; module_param (num_test,int,S_IRUGO); module_param (steing_test,charp,S_ITUGO);
在装载模块时，用户可以给模块传递参数，形式为：”insmod 模块名 参数名=参数值”，如果不传递，则参数使用默认的参数值
参数的类型可以是：byte,short,ushort,int,uint,long,ulong,charp,bool；
权限：定义在linux/stat.h中，控制存取权限，S_IRUGO表示所有用户只读；
模块被加载后，在sys/module/下会出现以此模块命名的目录，当读写权限为零时：表示此参数不存在sysfs文件系统下的文件节点，当读写权限不为零时：此模块的目录下会存在parameters目录，包含一系列以参数名命名的文件节点，这些文件节点的权限值就是传入module_param()的“参数读/写权限“，而该文件的内容为参数的值。
除此之外，模块也可以拥有参数数组，形式为：”module_param_array(数组名、数组类型、数组长、参数读写权限等)”，当不需要保存实际的输入的数组元素的个数时，可以设置“数组长“为0。
运行insmod时，使用逗号分隔输入的数组元素。
下面是一个实际的例子，来说明模块传参的过程。
[cpp] view plaincopyprint?
#include <linux/module.h> /*module_init()*/
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
#define DEBUG //open debug message
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg)
#else
#define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
#endif
static char *string_test="default paramater";
static int num_test=1000;
static int __init hello_init(void)
{
PRINTK("\nthe string_test is : %s\n",string_test);
PRINTK("the num_test is : %d\n",num_test);
return 0;
}
static void __exit hello_exit(void)
{
PRINTK(" input paramater module exit\n ");
}
module_init(hello_init);
module_exit(hello_exit);
module_param(num_test,int,S_IRUGO);
module_param(string_test,charp,S_IRUGO);
MODULE_AUTHOR("dengwei");
MODULE_LICENSE("GPL");
#include <linux/module.h> /*module_init()*/ #include <linux/kernel.h> /* printk() */ #include <linux/init.h> /* __init __exit */ #define DEBUG //open debug message #ifdef DEBUG #define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg) #else #define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) #endif static char *string_test="default paramater"; static int num_test=1000; static int __init hello_init(void) { PRINTK("\nthe string_test is : %s\n",string_test); PRINTK("the num_test is : %d\n",num_test); return 0; } static void __exit hello_exit(void) { PRINTK(" input paramater module exit\n "); } module_init(hello_init); module_exit(hello_exit); module_param(num_test,int,S_IRUGO); module_param(string_test,charp,S_IRUGO); MODULE_AUTHOR("dengwei"); MODULE_LICENSE("GPL");
当执行 insmod hello_param.ko时，执行dmesg 查看内核输出信息：
[cpp] view plain copy print ?
Hello World enter
the test string is： this is a test
the test num is ：1000
Hello World enter the test string is： this is a test the test num is ：1000
当执行insmod hello_param.ko num_test=2000 string_test=“edit by dengwei”，执行dmesg查看内核输出信息：
[cpp] view plain copy print ?
Hello World enter
the test string is： edit by dengwei
the test num is ：2000
Hello World enter the test string is： edit by dengwei the test num is ：2000
2）导出模块及符号的相互引用
Linux2.6内核的“/proc/kallsyms“文件对应内核符号表，它记录了符号以及符号所在的内存地址，模块可以使用下列宏导到内核符号表中。
EXPORT_SYMBOL(符号名)； 任意模块均可
EXPORT_SYMBOL_GPL(符号名)； 只使用于包含GPL许可权的模块
导出的符号可以被其它模块使用，使用前声明一下即可。
下面给出一个简单的例子：将add sub符号导出到内核符号表中，这样其它的模块就可以利用其中的函数
[cpp] view plain copy print ?
#include <linux/module.h> /*module_init()*/
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
int add_test(int a ,int b)
{
return a + b;
}
int sub_test(int a,int b)
{
return a - b;
}
EXPORT_SYMBOL(add_test);
EXPORT_SYMBOL(sub_test);
MODULE_AUTHOR("dengwei");
MODULE_LICENSE("GPL");
#include <linux/module.h> /*module_init()*/ #include <linux/kernel.h> /* printk() */ #include <linux/init.h> /* __init __exit */ int add_test(int a ,int b) { return a + b; } int sub_test(int a,int b) { return a - b; } EXPORT_SYMBOL(add_test); EXPORT_SYMBOL(sub_test); MODULE_AUTHOR("dengwei"); MODULE_LICENSE("GPL");
执行 cat/proc/kallsyms | grep test 即可找到以下信息，表示模块确实被加载到内核表中。
[cpp] view plain copy print ?
f88c9008 r __ksymtab_sub_integar [export_symb]
f88c9020 r __kstrtab_sub_integar [export_symb]
f88c9018 r __kcrctab_sub_integar [export_symb]
f88c9010 r __ksymtab_add_integar [export_symb]
f88c902c r __kstrtab_add_integar [export_symb]
f88c901c r __kcrctab_add_integar [export_symb]
f88c9000 T add_tes [export_symb]
f88c9004 T sub_tes [export_symb]
13db98c9 a __crc_sub_integar [export_symb]
e1626dee a __crc_add_integar [export_symb]
f88c9008 r __ksymtab_sub_integar [export_symb] f88c9020 r __kstrtab_sub_integar [export_symb] f88c9018 r __kcrctab_sub_integar [export_symb] f88c9010 r __ksymtab_add_integar [export_symb] f88c902c r __kstrtab_add_integar [export_symb] f88c901c r __kcrctab_add_integar [export_symb] f88c9000 T add_tes [export_symb] f88c9004 T sub_tes [export_symb] 13db98c9 a __crc_sub_integar [export_symb] e1626dee a __crc_add_integar [export_symb]
在其它模块中可以引用此符号
[cpp] view plain copy print ?
#include <linux/module.h> /*module_init()*/
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
#define DEBUG //open debug message
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg)
#else
#define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
#endif
extern int add_test(int a ,int b);
extern int sub_test(int a,int b);
static int __init hello_init(void)
{
int a,b;
a = add_test(10,20);
b = sub_test(30,20);
PRINTK("the add test result is %d",a);
PRINTK("the sub test result is %d\n",b);
return 0;
}
static void __exit hello_exit(void)
{
PRINTK(" Hello World exit\n ");
}
module_init(hello_init);
module_exit(hello_exit);
MODULE_AUTHOR("dengwei");
MODULE_LICENSE("GPL");
#include <linux/module.h> /*module_init()*/ #include <linux/kernel.h> /* printk() */ #include <linux/init.h> /* __init __exit */ #define DEBUG //open debug message #ifdef DEBUG #define PRINTK(fmt, arg...) printk(KERN_WARNING fmt, ##arg) #else #define PRINTK(fmt, arg...) printk(KERN_DEBUG fmt, ##arg) #endif extern int add_test(int a ,int b); extern int sub_test(int a,int b); static int __init hello_init(void) { int a,b; a = add_test(10,20); b = sub_test(30,20); PRINTK("the add test result is %d",a); PRINTK("the sub test result is %d\n",b); return 0; } static void __exit hello_exit(void) { PRINTK(" Hello World exit\n "); } module_init(hello_init); module_exit(hello_exit); MODULE_AUTHOR("dengwei"); MODULE_LICENSE("GPL");
303
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
