轉自：https://blog.csdn.net/richard_liujh/article/details/46758073
版權聲明：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/Richard_LiuJH/article/details/46758073
Linux內核很吊之 module_init解析 （下）
個人筆記，歡迎轉載，請注明出處，共同分享 共同進步
http://blog.csdn.net/richard_liujh/article/details/46758073 -- 劉金輝
忙了一段時間，終於有時間把inux內核很吊之 module_init解析 （下）整理完畢。
從上一篇博文http://blog.csdn.net/richard_liujh/article/details/45669207介紹了module_init宏函數，簡單來說上篇博文介紹module_init如何注冊驅動的init函數，這篇博文將詳細分析kernel啟動過程又是如何執行我們注冊的init函數。
如果了解過linux操作系統啟動流程，那么當bootloader加載完kernel並解壓並放置與內存中准備開始運行，首先被調用的函數是start_kernel。start_kernel函數顧名思義，內核從此准備開啟了，但是start_kernel做的事情非常多，簡單來說為內核啟動做准備工作，復雜來說也是非常之多（包含了自旋鎖檢查、初始化棧、CPU中斷、立即數、初始化頁地址、內存管理等等等...）。所以這篇博文我們還是主要分析和module_init注冊函數的執行過程。
start_kernel函數在 init/main.c文件中，由於start_kernel本身功能也比較多，所以為了簡介分析過程我把函數從start_kernel到do_initcalls的調用過程按照如下方式展現出來
start_kernel -> reset_init -> kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
|
|->static int __ref kernel_init(void *unused)
|
|-> kernel_init_freeable( )
|
|-> do_basic_setup();
|
|——> do_initcalls();
在上面的調用過程中，通過kernel_thread注冊了一個任務kernel_init，kernel_thread的函數原型如下。
/*
* Create a kernel thread.
*/
pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
(unsigned long)arg, NULL, NULL);
}
kernel_thread創建了一個內核線程，也就是創建一個線程完成kernel_init的任務。通過kernel_init的逐層調用，最后調用到我們目前最應該關心的函數do_initcalls；
do_initcalls函數如下
static void __init do_initcalls(void)
{
int level;
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
do_initcall_level(level);
}
這個函數看起來就非常簡單了，里面有for循環，每循環一次就調用一次do_initcall_level(level)；其實可以發現在我們分析kernel源碼時，大部分函數都能從函數名猜到函數的功能，這也是一名優秀程序猿的體現，大道至簡，悟在天成。
接下來我們就開始具體分析do_initcalls函數啦~~
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
這句for循環很簡單，循環執行條件是level < ARRAY_SIZE(initcall_levels)。
ARRAY_SIZE是一個宏，用於求數組元素的個數，在文件include\linux\kernel.h文件中
#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的定義
static initcall_t *initcall_levels[] __initdata = {
__initcall0_start,
__initcall1_start,
__initcall2_start,
__initcall3_start,
__initcall4_start,
__initcall5_start,
__initcall6_start,
__initcall7_start,
__initcall_end,
};
這個數組可不能小看他，如果看過module_init解析(上)的朋友，對數組里面的名字“__initcall0 __initcall1 ... __initcall7”有一點點印象吧。
談到數組，我們知道是元素的集合，那么initcall_levels數組中得元素是什么？？？（看下面的分析前，請先弄清楚數組指針 和指針數組的區別，不然容易走火入魔...）
static initcall_t *initcall_levels[] __initdata = {
很顯然，這個數組定義非常高大上。不管如何高大上，總離不開最基本的知識吧。所以我先從兩點去探索：
1. 數組的名字，根據數組標志性的‘[ ]’，我們應該很容易知道數組名字是initcall_levels
2.數組的元素類型，由於定義中出現了指針的符號‘ * ’，也很容知道initcall_levels原來是一個指針數組啦。
所以現在我們知道了initcall_levels數組里面保存的是指針啦，也就是指針的一個集合而已。掰掰腳趾數一下也能知道initcall_levels數組里面有9個元素，他們都是指針。哈哈
對於這個數組，我們先暫且到這兒，因為我們已經知道了數組的個數了，也就知道for循環的循環次數。（后面還會繼續分析這個數組，所以要由印象）
我們再回來看看do_initcalls：
static void __init do_initcalls(void)
{
int level;
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
do_initcall_level(level);
}
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函數原型如下：
static void __init do_initcall_level(int level)
{
extern const struct kernel_param __start___param[], __stop___param[];
initcall_t *fn;
strcpy(static_command_line, saved_command_line);
parse_args(initcall_level_names[level],
static_command_line, __start___param,
__stop___param - __start___param,
level, level,
&repair_env_string);
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
do_one_initcall(*fn);
}
在do_initcall_level函數中，有如下部分是和內核初始化過程調用parse_args對選項進行解析並調用相關函數去處理的。其中的__start___param和__stop___param也是可以在內核鏈接腳本vmlinux.lds中找到的。
extern const struct kernel_param __start___param[], __stop___param[];
strcpy(static_command_line, saved_command_line);
parse_args(initcall_level_names[level],
static_command_line, __start___param,
__stop___param - __start___param,
level, level,
&repair_env_string);
如果將上面初始化過程中命令行參數解析過程忽略，那么就剩下的內容也就是我們最想看到的內容了
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
do_one_initcall(*fn);
這個也很簡單，不就是一個for循環嘛，so easy~！！
那么接下來我們就開始分析這個for循環：
1. for循環開始，fn = initcall_levels[level]，initcall_levels是上面分析過的數組，數組里面存放着指針，所以fn也應該是指針咯。那么看看fn的定義
initcall_t *fn;
fn確實是一個initcall_t類型的指針，那initcall_t是什么？
在文件include\linux\init.h文件中找到其定義
/*
* Used for initialization calls..
*/
typedef int (*initcall_t)(void);
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數組了（之前暫時沒有分析的，現在開始分析了）
static initcall_t *initcall_levels[] __initdata = {
__initcall0_start,
__initcall1_start,
__initcall2_start,
__initcall3_start,
__initcall4_start,
__initcall5_start,
__initcall6_start,
__initcall7_start,
__initcall_end,
};
已經知道了initcall_levels是一個指針數組，也就是說數組的元素都是指針，指針是指向什么類型的數據呢？ 是initcall_t類型的，上面剛剛分析過initcall_t是函數指針的類型定義。
這樣一來，initcall_levels數組里面保存的元素都是函數指針啦。
很顯然這是通過枚舉的方式定義了數組initcall_levels，那么元素值是多少？？（數組中元素是分別是 __initcall0_start __initcall1_start __initcall2_start ... __initcall7_start __initcall_end）
通過尋找會發現在main.c文件中有如下的聲明
extern initcall_t __initcall_start[];
extern initcall_t __initcall0_start[];
extern initcall_t __initcall1_start[];
extern initcall_t __initcall2_start[];
extern initcall_t __initcall3_start[];
extern initcall_t __initcall4_start[];
extern initcall_t __initcall5_start[];
extern initcall_t __initcall6_start[];
extern initcall_t __initcall7_start[];
extern initcall_t __initcall_end[];
所以__initcall0_start __initcall1_start __initcall2_start ... __initcall7_start __initcall_end都是initcall_t類型的數組名，數組名也就是指針。只是這些都是extern聲明的，所以在本文件里面找不到他們的定義出。那么他們在哪一個文件？？答案還是 鏈接腳本 vmlinux.lds，而且我們已經看過這些名字很多次了...
下面再次把鏈接腳本中相關的內容拿出來：（相關的解釋請參考 module_init 解析--上）
__init_begin = .;
. = ALIGN(4096); .init.text : AT(ADDR(.init.text) - 0) { _sinittext = .; *(.init.text) *(.cpuinit.text) *(.meminit.text) _einittext = .; }
.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) }
. = ALIGN(4);
所以在main.c文件中extern聲明的那些數組__initcall0_start ... __initcall7_start __initcall_end其實就是上面鏈接腳本vmlinux.lds中定義的標號（也可以暫且簡單粗暴認為是地址）。
為了好理解，把其中的__initcall0_start單獨拿出來
__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循環
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
<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
了解這一點，我們已經接近勝利的彼岸~~
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
do_one_initcall(*fn);
最后我們要了解的就是for循環每次執行的內容do_one_initcall(*fn)，其函數原型如下
int __init_or_module do_one_initcall(initcall_t fn)
{
int count = preempt_count();
int ret;
if (initcall_debug)
ret = do_one_initcall_debug(fn);
else
ret = fn();
msgbuf[0] = 0;
if (preempt_count() != count) {
sprintf(msgbuf, "preemption imbalance ");
preempt_count() = count;
}
if (irqs_disabled()) {
strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
local_irq_enable();
}
WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
return ret;
}
do_one_initcall函數就非常簡單了，讓我們看看最重要的內容如下
if (initcall_debug)
ret = do_one_initcall_debug(fn);
else
ret = fn();
這里就是判斷是不是debug模式，無非debug會多一些調試的操作。但是不管是哪一種，他們都執行 ret = fn( );
因為fn就是函數指針，fn指向的是我們注冊到__initcall0_start ... __initcall7_start的一系列函數。所以 fn( ); 就是調用這些函數。當然也包括了驅動中module_init注冊的函數啦，只是通過module_init注冊的level等級是6，for循環是從level = 0開始的，這也能看出0是優先級最高，7是優先級最低的。
到現在，module_init的作用已經全部分析完畢~
---------------------
作者：Richard_LiuJH
來源：CSDN
原文：https://blog.csdn.net/richard_liujh/article/details/46758073
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！