本文转载自博客http://blog.csdn.net/u013216061/article/details/72511653

如果了解过Linux操作系统启动流程,那么当bootloader加载完kernel并解压并放置与内存中准备开始运行,首先被调用的函数是start_kernel。start_kernel函数顾名思义,内核从此准备开启了,但是start_kernel做的事情非常多,简单来说为内核启动做准备工作,复杂来说也是非常之多(包含了自旋锁检查、初始化栈、CPU中断、立即数、初始化页地址、内存管理等等等...)。所以这篇博文我们还是主要分析和module_init注册函数的执行过程。

start_kernel函数在 init/main.c文件中,由于start_kernel本身功能也比较多,所以为了简介分析过程我把函数从start_kernel到do_initcalls的调用过程按照如下方式展现出来

  1. start_kernel -> reset_init -> kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
  2. |
  3. |->static int __ref kernel_init(void *unused)
  4. |
  5. |-> kernel_init_freeable( )
  6. |
  7. |-> do_basic_setup();
  8. |
  9. |——> do_initcalls();

在上面的调用过程中,通过kernel_thread注册了一个任务kernel_init,kernel_thread的函数原型如下。

  1. /*
  2. * Create a kernel thread.
  3. */
  4. pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
  5. {
  6. return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
  7. (unsigned long)arg, NULL, NULL);
  8. }

kernel_thread创建了一个内核线程,也就是创建一个线程完成kernel_init的任务。通过kernel_init的逐层调用,最后调用到我们目前最应该关心的函数do_initcalls;

do_initcalls函数如下

  1. static void __init do_initcalls(void)
  2. {
  3. int level;
  4. for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
  5. do_initcall_level(level);
  6. }

这个函数看起来就非常简单了,里面有for循环,每循环一次就调用一次do_initcall_level(level);其实可以发现在我们分析kernel源码时,大部分函数都能从函数名猜到函数的功能,这也是一名优秀程序猿的体现,大道至简,悟在天成。

接下来我们就开始具体分析do_initcalls函数啦~~

  1. for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)

这句for循环很简单,循环执行条件是level < ARRAY_SIZE(initcall_levels)。

ARRAY_SIZE是一个宏,用于求数组元素的个数,在文件include\linux\kernel.h文件中

  1. #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))

当然ARRAY_SIZE宏里面还多了一个__must_be_array(),这个主要是确保我们传过来的arr是一个数组,防止ARRAY_SIZE的误用。所以在我们写kernel驱动程序时,遇到需要求一个数组的大小请记得使用ARRAY_SIZE。有安全感又高大上...哈哈

那么,initcall_levels是不是数组呢?如果是,里面有什么内容?

还是在文件main.c中有数组initcall_levels的定义

  1. static initcall_t *initcall_levels[] __initdata = {
  2. __initcall0_start,
  3. __initcall1_start,
  4. __initcall2_start,
  5. __initcall3_start,
  6. __initcall4_start,
  7. __initcall5_start,
  8. __initcall6_start,
  9. __initcall7_start,
  10. __initcall_end,
  11. };

这个数组可不能小看他,如果看过module_init解析(上)的朋友,对数组里面的名字“__initcall0 __initcall1 ... __initcall7”有一点点印象吧。

谈到数组,我们知道是元素的集合,那么initcall_levels数组中得元素是什么???

  1. static initcall_t *initcall_levels[] __initdata = {

很显然,这个数组定义非常高大上。不管如何高大上,总离不开最基本的知识吧。所以我先从两点去探索:

1. 数组的名字,根据数组标志性的‘[ ]’,我们应该很容易知道数组名字是initcall_levels

2.数组的元素类型,由于定义中出现了指针的符号‘ * ’,也很容知道initcall_levels原来是一个指针数组啦。

所以现在我们知道了initcall_levels数组里面保存的是指针啦,也就是指针的一个集合而已。掰掰脚趾数一下也能知道initcall_levels数组里面有9个元素,他们都是指针。哈哈

对于这个数组,我们先暂且到这儿,因为我们已经知道了数组的个数了,也就知道for循环的循环次数。(后面还会继续分析这个数组,所以要由印象)

我们再回来看看do_initcalls:

  1. static void __init do_initcalls(void)
  2. {
  3. int level;
  4. for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
  5. do_initcall_level(level);
  6. }
ARRAY_SIZE求出了数组initcall_levels的元素个数为9,所以level变量从 0 ~ 7都是满足level < ARRAY_SIZE(initcall_levels) - 1既level < 9 - 1。一共循环了8次。

循环8此就调用了do_initcall_level(level) 8次。
do_initcall_level函数原型如下:

  1. static void __init do_initcall_level(int level)
  2. {
  3. extern const struct kernel_param __start___param[], __stop___param[];
  4. initcall_t *fn;
  5. strcpy(static_command_line, saved_command_line);
  6. parse_args(initcall_level_names[level],
  7. static_command_line, __start___param,
  8. __stop___param - __start___param,
  9. level, level,
  10. &repair_env_string);
  11. for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
  12. do_one_initcall(*fn);
  13. }

在do_initcall_level函数中,有如下部分是和内核初始化过程调用parse_args对选项进行解析并调用相关函数去处理的。其中的__start___param和__stop___param也是可以在内核链接脚本vmlinux.lds中找到的。

  1. extern const struct kernel_param __start___param[], __stop___param[];
  2. strcpy(static_command_line, saved_command_line);
  3. parse_args(initcall_level_names[level],
  4. static_command_line, __start___param,
  5. __stop___param - __start___param,
  6. level, level,
  7. &repair_env_string);
如果将上面初始化过程中命令行参数解析过程忽略,那么就剩下的内容也就是我们最想看到的内容了
  1. for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
  2. do_one_initcall(*fn);

这个也很简单,不就是一个for循环嘛,so easy~!!

那么接下来我们就开始分析这个for循环:

1. for循环开始,fn = initcall_levels[level],initcall_levels是上面分析过的数组,数组里面存放着指针,所以fn也应该是指针咯。那么看看fn的定义

  1. initcall_t *fn;

fn确实是一个initcall_t类型的指针,那initcall_t是什么?

在文件include\linux\init.h文件中找到其定义

  1. /*
  2. * Used for initialization calls..
  3. */
  4. typedef int (*initcall_t)(void);
  5. typedef void (*exitcall_t)(void);

从上面的定义可以知道,initcall_t原来是一个函数指针的类型定义。函数的返回值是int类型,参数是空 void。从注释也可以看出,initcall_t是初始化调用的。
简单来说,fn是一个函数指针。

2. 每循环一次,fn++。循环执行的条件是fn < initcall_levels[level+1];

这里fn++就不是很容易理解了,毕竟不是一个普通的变量而是一个函数指针,那么fn++有何作用呢??

首先,fn = initcall_levels[level],所以我们还是有必要去再看看initcall_levels数组了(之前暂时没有分析的,现在开始分析了)

  1. static initcall_t *initcall_levels[] __initdata = {
  2. __initcall0_start,
  3. __initcall1_start,
  4. __initcall2_start,
  5. __initcall3_start,
  6. __initcall4_start,
  7. __initcall5_start,
  8. __initcall6_start,
  9. __initcall7_start,
  10. __initcall_end,
  11. };

已经知道了initcall_levels是一个指针数组,也就是说数组的元素都是指针,指针是指向什么类型的数据呢? 是initcall_t类型的,上面刚刚分析过initcall_t是函数指针的类型定义。

这样一来,initcall_levels数组里面保存的元素都是数组指针啦。

很显然这是通过枚举的方式定义了数组initcall_levels,那么元素值是多少??(数组中元素是分别是 __initcall0_start __initcall1_start __initcall2_start ... __initcall7_start __initcall_end)

通过寻找会发现在main.c文件中有如下的声明

  1. extern initcall_t __initcall_start[];
  2. extern initcall_t __initcall0_start[];
  3. extern initcall_t __initcall1_start[];
  4. extern initcall_t __initcall2_start[];
  5. extern initcall_t __initcall3_start[];
  6. extern initcall_t __initcall4_start[];
  7. extern initcall_t __initcall5_start[];
  8. extern initcall_t __initcall6_start[];
  9. extern initcall_t __initcall7_start[];
  10. extern initcall_t __initcall_end[];

所以__initcall0_start __initcall1_start __initcall2_start ... __initcall7_start __initcall_end都是initcall_t类型的数组名,数组名也就是指针。只是这些都是extern声明的,所以在本文件里面找不到他们的定义出。那么他们在哪一个文件??答案还是 链接脚本 vmlinux.lds,而且我们已经看过这些名字很多次了...

  1. __init_begin = .;
  2. . = ALIGN(4096); .init.text : AT(ADDR(.init.text) - 0) { _sinittext = .; *(.init.text) *(.cpuinit.text) *(.meminit.text) _einittext = .; }
  3. .init.data : AT(ADDR(.init.data) - 0) { *(.init.data) *(.cpuinit.data) *(.meminit.data) *(.init.rodata) *(.cpuinit.rodata) *(.meminit.rodata) . = ALIGN(32); __dtb_start = .; *(.dtb.init.rodata) __dtb_end = .; . = ALIGN(16); __setup_start = .; *(.init.setup) __setup_end = .; __initcall_start = .; *(.initcallearly.init) __initcall0_start = .; *(.initcall0.init) *(.initcall0s.init) __initcall1_start = .; *(.initcall1.init) *(.initcall1s.init) __initcall2_start = .; *(.initcall2.init) *(.initcall2s.init) __initcall3_start = .; *(.initcall3.init) *(.initcall3s.init) __initcall4_start = .; *(.initcall4.init) *(.initcall4s.init) __initcall5_start = .; *(.initcall5.init) *(.initcall5s.init) __initcallrootfs_start = .; *(.initcallrootfs.init) *(.initcallrootfss.init) __initcall6_start = .; *(.initcall6.init) *(.initcall6s.init) __initcall7_start = .; *(.initcall7.init) *(.initcall7s.init) __initcall_end = .; __con_initcall_start = .; *(.con_initcall.init) __con_initcall_end = .; __security_initcall_start = .; *(.security_initcall.init) __security_initcall_end = .; . = ALIGN(4); __initramfs_start = .; *(.init.ramfs) . = ALIGN(8); *(.init.ramfs.info) }
  4. . = ALIGN(4);

所以在main.c文件中extern声明的那些数组__initcall0_start  ... __initcall7_start __initcall_end其实就是上面链接脚本vmlinux.lds中定义的标号(也可以暂且简单粗暴认为是地址)。
为了好理解,把其中的__initcall0_start单独拿出来

  1. __initcall0_start = .; *(.initcall0.init) *(.initcall0s.init)

这里的意思是,__initcall0_start 是一段地址的开始,从这个地址开始链接所有.initcall0.init和.initcall0s.init段的内容。那.initcall0.init和.initcall0s.init段有什么东东??这就是上篇博文中解释的。简单来说,就是我们通过module_init(xxx)添加的内容,只是module_init对应的level值默认为6而已。

总而言之,__initcallN_start(其中N = 0,1,2...7)地址开始存放了一系列优先级为N的函数。我们通过module_init注册的函数优先级为6

现在我们回过头再去看看上面的for循环

  1. for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
  2. <span style="white-space: pre;">      </span>do_one_initcall(*fn);

一开始fn = initcall_levels[level],假设level = 0。也就是fn = initcall_levels[0] = __initcall0_start。所以fn指向了链接脚本中的__initcall0_start地址,每当fn++也就是fn逐次指向注册到.initcall0.init和.initcall0s.init段中的函数地址了。for循环的条件是fn <initcall_levels[level + 1] = initcall_levels[0 + 1] = initcall_level[1] = __initcall1_start。

为了能直观看出fn增加的范围,用如下的简易方式表达一下。

__initcall0_start  __initcall1_start  __initcall2_start  __initcall3_start ... ... __initcall7_start  __initcall_end

| <----- fn++ ---->|| <----- fn++ --->| | <----- fn++ --->| | <----- fn++ --->|... ... | <----- fn++ --->| END

了解这一点,我们已经接近胜利的彼岸~~

  1. for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
  2. do_one_initcall(*fn);

最后我们要了解的就是for循环每次执行的内容do_one_initcall(*fn),其函数原型如下

  1. int __init_or_module do_one_initcall(initcall_t fn)
  2. {
  3. int count = preempt_count();
  4. int ret;
  5. if (initcall_debug)
  6. ret = do_one_initcall_debug(fn);
  7. else
  8. ret = fn();
  9. msgbuf[0] = 0;
  10. if (preempt_count() != count) {
  11. sprintf(msgbuf, "preemption imbalance ");
  12. preempt_count() = count;
  13. }
  14. if (irqs_disabled()) {
  15. strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
  16. local_irq_enable();
  17. }
  18. WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
  19. return ret;
  20. }

do_one_initcall函数就非常简单了,让我们看看最重要的内容如下:

  1. if (initcall_debug)
  2. ret = do_one_initcall_debug(fn);
  3. else
  4. ret = fn();

这里就是判断是不是debug模式,无非debug会多一些调试的操作。但是不管是哪一种,他们都执行 ret = fn( );
因为fn就是函数指针,fn指向的是我们注册到__initcall0_start  ... __initcall7_start的一系列函数。所以 fn( ); 就是调用这些函数。当然也包括了驱动中module_init注册的函数啦,只是通过module_init注册的level等级是6,for循环是从level = 0开始的,这也能看出0是优先级最高,7是优先级最低的。

linux内核驱动module_init解析(2)的更多相关文章

  1. linux内核驱动module_init解析(1)

    本文转载自博客http://blog.csdn.net/richard_liujh/article/details/45669207 写过linux驱动的程序猿都知道module_init() 这个函 ...

  2. linux 内核驱动--Platform Device和Platform_driver注册过程

    linux 内核驱动--Platform Device和Platform_driver注册过程 从 Linux 2.6 起引入了一套新的驱动管理和注册机制 :Platform_device 和 Pla ...

  3. Unix/Linux环境C编程新手教程(12) openSUSECCPP以及Linux内核驱动开发环境搭建

    1. openSUSE是一款优秀的linux. watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaXRjYXN0Y3Bw/font/5a6L5L2T/font ...

  4. Unix/Linux环境C编程入门教程(12) openSUSECCPP以及Linux内核驱动开发环境搭建

    1. openSUSE是一款优秀的linux. 2.选择默认虚拟机 3.选择稍后安装操作系统 4.选择linux  opensuse 5. 选择默认虚拟机名称 6.设置处理器为双核. 7.内存设置为2 ...

  5. 【Linux开发】Linux V4L2驱动架构解析与开发导引

    Linux V4L2驱动架构解析与开发导引 Andrew按:众所周知,linux中可以采用灵活的多层次的驱动架构来对接口进行统一与抽象,最低层次的驱动总是直接面向硬件的,而最高层次的驱动在linux中 ...

  6. Linux内核驱动学习(八)GPIO驱动模拟输出PWM

    文章目录 前言 原理图 IO模拟输出PWM 设备树 驱动端 调试信息 实验结果 附录 前言 上一篇的学习中介绍了如何在用户空间直接操作GPIO,并写了一个脚本可以产生PWM.本篇的学习会将写一个驱动操 ...

  7. Linux内核驱动学习(六)GPIO之概览

    文章目录 前言 功能 如何使用 设备树 API 总结 前言 GPIO(General Purpose Input/Output)通用输入/输出接口,是十分灵活软件可编程的接口,功能强大,十分常用,SO ...

  8. linux内核驱动模型

    linux内核驱动模型,以2.6.32内核为例.(一边写一边看的,有点乱.) 1.以内核对象为基础.用kobject表示,相当于其它对象的基类,是构建linux驱动模型的关键.具有相同类型的内核对象构 ...

  9. 【引用】Linux 内核驱动--多点触摸接口

    本文转载自James<Linux 内核驱动--多点触摸接口>   译自:linux-2.6.31.14\Documentation\input\multi-touch-protocol.t ...

随机推荐

  1. C++ 中set

    set特点: 所有元素不会重复,重复插入已经有的新值无效: 所有元素按顺序排列:unordered_set除外 键和值相同,所以set中的值是不可更改的 set的各成员函数列表如下: 1.begin( ...

  2. PS技巧集合

    一.把图片变模糊 图像——调整——色阶——输出色阶——滤镜——模糊——高斯模糊——半径 二.图片换色 点击右下角弹层下方的“fx”——颜色叠加——色样颜色

  3. 利用SQL语句查找某数据库中所有存储过程包含的内容(转)

    Use 数据库DECLARE @ProcName varchar(50)Create Table #tmpName(Content  varchar(2000))Create Table #tmp(P ...

  4. linux查询日志命令总结

    [背景] 排查线上环境问题,少不了去线上查日志.而使用什么命令,能快速准确地查到我们需要查找地日志信息,也是我们需要掌握的一项技能. [命令] Linux查看命令有多种:tail,head,cat,t ...

  5. PJzhang:360压缩的用户许可协议和隐私政策阅读

    猫宁!!! 参考链接:http://yasuo.360.cn/ 当我们安装一个软件,不管是手机上的还是电脑上的,很少会去看它们的用户许可协议和隐私政策,而有的时候软件甚至都不提醒我们还有用户许可协议和 ...

  6. Spring MVC 源码 分析

    spring web 源码 @HandlesTypes(WebApplicationInitializer.class) public class SpringServletContainerInit ...

  7. ORACLE 更新 和 插入多条 数据

    --插入语句INSERT INTO OA_W_BAOXIAOMXYWB (ID,DONGTAITABLEPARENTSN,CHANPINNAMEGKFK,CHANPINJITIGKFK,CHANPIN ...

  8. SolidWorks学习笔记6抽壳,加强筋,扫描,放样

    抽壳 概念:移除一个或者多个面,然后将其余的模型外表面向内或者向外偏移相等或者不等的距离 针对不同面设置不同厚度 方向参考 有实体的一侧是内测, 没有实体的一侧是外侧 顺序 先圆角再抽壳 加强筋. 点 ...

  9. 如何用快排思想在O(n)内查找第K大元素--极客时间王争《数据结构和算法之美》

    前言 半年前在极客时间订阅了王争的<数据结构和算法之美>,现在决定认真去看看.看到如何用快排思想在O(n)内查找第K大元素这一章节时发现王争对归并和快排的理解非常透彻,讲得也非常好,所以想 ...

  10. Python中的逻辑运算符