(連載)Android 8.0 : 系統啟動流程之Linux核心

這是一個連載的博文系列，我將持續為大家提供儘可能透徹的Android原始碼分析 github連載地址

前言

Android本質上就是一個基於Linux核心的作業系統，與Ubuntu Linux、Fedora Linux類似，我們要講Android，必定先要了解一些Linux核心的知識。

Linux核心的東西特別多，我也不可能全部講完，由於本文主要講解Android系統啟動流程，所以這裡主要講一些核心啟動相關的知識。

Linux核心啟動主要涉及3個特殊的程式，idle程式(PID = 0), init程式(PID = 1)和kthreadd程式(PID = 2)，這三個程式是核心的基礎。

• idle程式是Linux系統第一個程式，是init程式和kthreadd程式的父程式
• init程式是Linux系統第一個使用者程式，是Android系統應用程式的始祖，我們的app都是直接或間接以它為父程式
• kthreadd程式是Linux系統核心管家，所有的核心執行緒都是直接或間接以它為父程式

本文將以這三個程式為線索，主要講解以下內容：

• idle程式啟動
• kthreadd程式啟動
• init程式啟動

本文涉及到的檔案

msm/arch/arm64/kernel/head.S
msm/init/main.c
msm/kernel/rcutree.c
msm/kernel/fork.c
msm/mm/mempolicy.c
msm/kernel/kthread.c
msm/include/linux/kthread.h
msm/include/linux/rcupdate.h
msm/kernel/rcupdate.c
msm/kernel/pid.c
msm/include/linux/sched.h
msm/kernel/sched/core.c
msm/kernel/cpu/idle.c
msm/drivers/base/init.c
複製程式碼

一、idle程式啟動

很多文章講Android都從init程式講起，它的程式號是1，既然程式號是1，那麼有沒有程式號是0的程式呢，其實是有的。

這個程式名字叫init_task，後期會退化為idle，它是Linux系統的第一個程式(init程式是第一個使用者程式)，也是唯一一個沒有通過fork或者kernel_thread產生的程式，它在完成初始化操作後，主要負責程式排程、交換。

idle程式的啟動是用匯編語言寫的，對應檔案是msm/arch/arm64/kernel/head.S，因為都是用匯編語言寫的，我就不多介紹了，具體可參考 kernel 啟動流程之head.S ,這裡面有一句比較重要

340 	str	x22, [x4]			// Save processor ID
341 	str	x21, [x5]			// Save FDT pointer
342 	str	x24, [x6]			// Save PHYS_OFFSET
343 	mov	x29, #0
344 	b	start_kernel        //跳轉start_kernel函式
複製程式碼

第344行，b start_kernel，b 就是跳轉的意思，跳轉到start_kernel.h，這個標頭檔案對應的實現在msm/init/main.c，start_kernel函式在最後會呼叫rest_init函式，這個函式開啟了init程式和kthreadd程式，我們著重分析下rest_init函式。

在講原始碼前，我先說明下我分析原始碼的寫作風格：

• 一般我會在函式下面寫明該函式所在的位置，比如定義在msm/init/main.c中，這樣大家就可以去專案裡找到原始檔
• 我會把原始碼相應的英文註釋也一併copy進來，這樣方便英文好的人可以看到原作者的註釋
• 我會盡可能將函式中每一行程式碼的作用註釋下(一般以//的形式註釋在程式碼結尾)，大家在看原始碼的同時就可以理解這段程式碼作用，這也是我花時間最多的,請大家務必認真看。我也想過在原始碼外部統一通過行號來解釋，但是感覺這樣需要大家一會兒看原始碼，一會兒看解釋，上下來回看不方便，所以乾脆寫在一起了
• 為了大家更好地閱讀註釋，我會手動做換行處理，//形式註釋可能會換行到句首，也就是可能會出現在程式碼下方
• 在函式結尾我儘可能總結下這個函式做了些什麼，以及這個函式涉及到的一些知識
• 對於重要的函式，我會將函式中每一個呼叫的子函式再單獨拿出來講解
• 考慮到大家都是開發Android的比較多，對C/C++不太瞭解，在註釋中我也會講一些C/C++的知識，方便大家理解，C語言註釋我一般用/** */的形式註釋在程式碼頂頭
• 為了更好的閱讀體驗，希望大家可以下載一下Source Insight同步看程式碼，使用教程 ,可以直接將專案中app/src/main/cpp作為目錄加入到Source Insight中

1.1 rest_init

定義在msm/init/main.c中

/*
 * 1.C語言oninline與inline是一對意義相反的關鍵字，inline的作用是編譯期間直接替換程式碼塊，也就是說編譯後就沒有這個方法了，
 * 而是直接把程式碼塊替換呼叫這個函式的地方，oninline就相反，強制不替換，保持原有的函式
 * 2.__init_refok是__init的擴充套件，__init 定義的初始化函式會放入名叫.init.text的輸入段，當核心啟動完畢後，
 * 這個段中的記憶體會被釋放掉，在本文中有講，關注3.5 free_initmem
 * 3.不帶引數的方法會加一個void引數
 */
static noinline void __init_refok rest_init(void)
{
	int pid;
	/*
	 * 1.C語言中const相當於Java中的final static， 表示常量
	 * 2.struct是結構體，相當於Java中定義了一個實體類，裡面只有一些成員變數，{.sched_priority =1 }相當於new，
	 * 然後將成員變數sched_priority的值賦為1
	 */
	const struct sched_param param = { .sched_priority = 1 }; //初始化優先順序為1的程式排程策略，
	//取值1~99，1為最小

	rcu_scheduler_starting(); //啟動RCU機制，這個與後面的rcu_read_lock和rcu_read_unlock是配套的，用於多核同步
	/*
	 * We need to spawn init first so that it obtains pid 1, however
	 * the init task will end up wanting to create kthreads, which, if
	 * we schedule it before we create kthreadd, will OOPS.
	 */

	/*
     * 1.C語言中支援方法傳參，kernel_thread是函式，kernel_init也是函式，但是kernel_init卻作為引數傳遞了過去，
     * 其實傳遞過去的是一個函式指標,參考[函式指標](http://www.cnblogs.com/haore147/p/3647262.html)
     * 2.CLONE_FS這種大寫的一般就是常量了，跟Java差不多
     */
	kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND); //用kernel_thread方式建立init程式，
	//CLONE_FS 子程式與父程式共享相同的檔案系統，包括root、當前目錄、umask，
	//CLONE_SIGHAND  子程式與父程式共享相同的訊號處理（signal handler）表

	numa_default_policy(); // 設定NUMA系統的預設記憶體訪問策略
	pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);//用kernel_thread方式建立kthreadd程式，
	//CLONE_FILES  子程式與父程式共享相同的檔案描述符（file descriptor）表

	rcu_read_lock(); //開啟RCU讀取鎖，在此期間無法進行程式切換
	/*
	 * C語言中&的作用是獲得變數的記憶體地址，參考[C指標](http://www.runoob.com/cprogramming/c-pointers.html)
	 */
	kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);// 獲取kthreadd的程式描述符，
	//期間需要檢索程式pid的使用連結串列，所以要加鎖

	rcu_read_unlock(); //關閉RCU讀取鎖
	sched_setscheduler_nocheck(kthreadd_task, SCHED_FIFO, &param); //設定kthreadd的程式排程策略，
	//SCHED_FIFO 實時排程策略，即馬上呼叫，先到先服務，param的優先順序之前定義為1
	
	complete(&kthreadd_done); // complete和wait_for_completion是配套的同步機制，跟java的notify和wait差不多，
	//之前kernel_init函式呼叫了wait_for_completion(&kthreadd_done)，
	//這裡呼叫complete就是通知kernel_init程式kthreadd程式已建立完成，可以繼續執行

	/*
	 * The boot idle thread must execute schedule()
	 * at least once to get things moving:
	 */
	init_idle_bootup_task(current);//current表示當前程式，當前0號程式init_task設定為idle程式
	schedule_preempt_disabled(); //0號程式主動請求排程，讓出cpu，1號程式kernel_init將會執行,並且禁止搶佔
	/* Call into cpu_idle with preempt disabled */
	cpu_startup_entry(CPUHP_ONLINE);// 這個函式會呼叫cpu_idle_loop()使得idle程式進入自己的事件處理迴圈
}
複製程式碼

rest_init的字面意思是剩餘的初始化，但是它卻一點都不剩餘，它建立了Linux系統中兩個重要的程式init和kthreadd，並且將init_task程式變為idle程式，接下來我將把rest_init中的方法逐個解析，方便大家理解。

1.2 rcu_scheduler_starting

定義在msm/kernel/rcutree.c

/*
 * This function is invoked towards the end of the scheduler's initialization
 * process.  Before this is called, the idle task might contain
 * RCU read-side critical sections (during which time, this idle
 * task is booting the system).  After this function is called, the
 * idle tasks are prohibited from containing RCU read-side critical
 * sections.  This function also enables RCU lockdep checking.
 */
void rcu_scheduler_starting(void)
{
	WARN_ON(num_online_cpus() != 1); //WARN_ON相當於警告，會列印出當前棧資訊，不會重啟， 
	//num_online_cpus表示當前啟動的cpu數
	
	WARN_ON(nr_context_switches() > 0); // nr_context_switches 進行程式切換的次數
	rcu_scheduler_active = 1; //啟用rcu機制
}
複製程式碼

1.3 kernel_thread

定義在msm/kernel/fork.c

/*
 * Create a kernel thread.
 */
 
/*
 * 1.C語言中 int (*fn)(void *)表示函式指標的定義，int是返回值，void是函式的引數，fn是名字
 * 2.C語言中 * 表示指標，這個用法很多
 * 3.unsigned表示無符號，一般與long,int,char等結合使用，表示範圍只有正數，
 * 比如init表示範圍-2147483648～2147483647 ，那unsigned表示範圍0～4294967295，足足多了一倍
 */
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);
}
複製程式碼

do_fork函式用於建立程式，它首先呼叫copy_process()建立新程式，然後呼叫wake_up_new_task()將程式放入執行佇列中並啟動新程式。 kernel_thread的第一個引數是一個函式引用，它相當於Java中的建構函式，會在建立程式後執行，第三個引數是建立程式的方式，具體如下：

引數名	作用
CLONE_PARENT	建立的子程式的父程式是呼叫者的父程式，新程式與建立它的程式成了“兄弟”而不是“父子”
CLONE_FS	子程式與父程式共享相同的檔案系統，包括root、當前目錄、umask
CLONE_FILES	子程式與父程式共享相同的檔案描述符（file descriptor）表
CLONE_NEWNS	在新的namespace啟動子程式，namespace描述了程式的檔案hierarchy
CLONE_SIGHAND	子程式與父程式共享相同的訊號處理（signal handler）表
CLONE_PTRACE	若父程式被trace，子程式也被trace
CLONE_UNTRACED	若父程式被trace，子程式不被trace
CLONE_VFORK	父程式被掛起，直至子程式釋放虛擬記憶體資源
CLONE_VM	子程式與父程式執行於相同的記憶體空間
CLONE_PID	子程式在建立時PID與父程式一致
CLONE_THREAD	Linux 2.4中增加以支援POSIX執行緒標準，子程式與父程式共享相同的執行緒群

1.4 kernel_init

定義在msm/init/main.c

這個函式比較重要，負責init程式的啟動，我將放在第三節重點講，這個函式首先呼叫kernel_init_freeable函式

static noinline void __init kernel_init_freeable(void)
{
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done);

	...
}

複製程式碼

wait_for_completion之前講了，與complete是配套的同步機制，這裡就是等待&kthreadd_done這個值complete，然後就可以繼續執行

1.5 numa_default_policy

定義在msm/mm/mempolicy.c

/* Reset policy of current process to default */
void numa_default_policy(void)
{
	do_set_mempolicy(MPOL_DEFAULT, 0, NULL); //設定NUMA系統的記憶體訪問策略為MPOL_DEFAULT
}
複製程式碼

1.6 kthreadd

定義在msm/kernel/kthread.c中

kthreadd程式我將在第二節中重點講，它是核心中重要的程式，負責核心執行緒的排程和管理，核心執行緒基本都是以它為父程式的

1.7 rcu_read_lock & rcu_read_unlock

定義在msm/include/linux/rcupdate.h和msm/kernel/rcupdate.c中

RCU（Read-Copy Update）是資料同步的一種方式，在當前的Linux核心中發揮著重要的作用。RCU主要針對的資料物件是連結串列，目的是提高遍歷讀取資料的效率，為了達到目的使用RCU機制讀取資料的時候不對連結串列進行耗時的加鎖操作。這樣在同一時間可以有多個執行緒同時讀取該連結串列，並且允許一個執行緒對連結串列進行修改（修改的時候，需要加鎖）

static inline void rcu_read_lock(void)
{
	__rcu_read_lock();
	__acquire(RCU);
	rcu_lock_acquire(&rcu_lock_map);
	rcu_lockdep_assert(!rcu_is_cpu_idle(),
			   "rcu_read_lock() used illegally while idle");
}

static inline void rcu_read_unlock(void)
{
	rcu_lockdep_assert(!rcu_is_cpu_idle(),
			   "rcu_read_unlock() used illegally while idle");
	rcu_lock_release(&rcu_lock_map);
	__release(RCU);
	__rcu_read_unlock();
}
複製程式碼

1.8 find_task_by_pid_ns

定義在msm/kernel/pid.c中

task_struct叫程式描述符，這個結構體包含了一個程式所需的所有資訊，它定義在msm/include/linux/sched.h檔案中。

它的結構十分複雜，本文就不重點講了，可以參考Linux程式描述符task_struct結構體詳解

/*
 * Must be called under rcu_read_lock().
 */
struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns)
{
	rcu_lockdep_assert(rcu_read_lock_held(),
			   "find_task_by_pid_ns() needs rcu_read_lock()"
			   " protection"); //必須進行RCU加鎖
	return pid_task(find_pid_ns(nr, ns), PIDTYPE_PID);
}

struct pid *find_pid_ns(int nr, struct pid_namespace *ns)
{
	struct upid *pnr;

	hlist_for_each_entry_rcu(pnr,
			&pid_hash[pid_hashfn(nr, ns)], pid_chain)
			/*
			 * C語言中 -> 用於指向結構體 struct 中的資料
			 */
		if (pnr->nr == nr && pnr->ns == ns)
			return container_of(pnr, struct pid,
					numbers[ns->level]); //遍歷hash表，找到struct pid

	return NULL;
}

struct task_struct *pid_task(struct pid *pid, enum pid_type type)
{
	struct task_struct *result = NULL;
	if (pid) {
		struct hlist_node *first;
		first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]),
					      lockdep_tasklist_lock_is_held());
		if (first)
			result = hlist_entry(first, struct task_struct, pids[(type)].node); //從hash表中找出struct task_struct
	}
	return result;
}
複製程式碼

find_task_by_pid_ns的作用就是根據pid，在hash表中獲得對應pid的task_struct

1.9 sched_setscheduler_nocheck

定義在msm/kernel/sched/core.c中

int sched_setscheduler_nocheck(struct task_struct *p, int policy,
			       const struct sched_param *param)
{
	struct sched_attr attr = {
		.sched_policy   = policy,
		.sched_priority = param->sched_priority
	};
	return __sched_setscheduler(p, &attr, false); //設定程式排程策略
}
複製程式碼

linux核心目前實現了6種排程策略(即排程演算法), 用於對不同型別的程式進行排程, 或者支援某些特殊的功能

• SCHED_FIFO和SCHED_RR和SCHED_DEADLINE則採用不同的排程策略排程實時程式，優先順序最高

• SCHED_NORMAL和SCHED_BATCH排程普通的非實時程式，優先順序普通

• SCHED_IDLE則在系統空閒時呼叫idle程式，優先順序最低

1.10 init_idle_bootup_task

定義在msm/kernel/sched/core.c中

void __cpuinit init_idle_bootup_task(struct task_struct *idle)
{
	idle->sched_class = &idle_sched_class; //設定程式的排程器類為idle_sched_class
}
複製程式碼

Linux依據其排程策略的不同實現了5個排程器類, 一個排程器類可以用一種種或者多種排程策略排程某一類程式, 也可以用於特殊情況或者排程特殊功能的程式.

其所屬程式的優先順序順序為

stop_sched_class -> dl_sched_class -> rt_sched_class -> fair_sched_class -> idle_sched_class
複製程式碼

可見idle_sched_class的優先順序最低，只有系統空閒時才呼叫idle程式

1.11 schedule_preempt_disabled

定義在msm/kernel/sched/core.c中

/**
 * schedule_preempt_disabled - called with preemption disabled
 *
 * Returns with preemption disabled. Note: preempt_count must be 1
 */
void __sched schedule_preempt_disabled(void)
{
	sched_preempt_enable_no_resched(); //開啟核心搶佔
	schedule();  // 並主動請求排程，讓出cpu
	preempt_disable(); // 關閉核心搶佔
}
複製程式碼

1.9到1.11都涉及到Linux的程式排程問題，可以參考 Linux使用者搶佔和核心搶佔詳解

1.12 cpu_startup_entry

定義在msm/kernel/cpu/idle.c中

void cpu_startup_entry(enum cpuhp_state state)
{
	/*
	 * This #ifdef needs to die, but it's too late in the cycle to
	 * make this generic (arm and sh have never invoked the canary
	 * init for the non boot cpus!). Will be fixed in 3.11
	 */
	 
	 
	 /*
	  * 1.C語言中#ifdef和#else、#endif是條件編譯語句，也就是說在滿足某些條件的時候，
	  * 夾在這幾個關鍵字中間的程式碼才編譯，不滿足就不編譯
	  * 2.下面這句話的意思就是如果定義了CONFIG_X86這個巨集，就把boot_init_stack_canary這個程式碼編譯進去
	  */
#ifdef CONFIG_X86
	/*
	 * If we're the non-boot CPU, nothing set the stack canary up
	 * for us. The boot CPU already has it initialized but no harm
	 * in doing it again. This is a good place for updating it, as
	 * we wont ever return from this function (so the invalid
	 * canaries already on the stack wont ever trigger).
	 */
	boot_init_stack_canary();//只有在x86這種non-boot CPU機器上執行，該函式主要用於初始化stack_canary的值,用於防止棧溢位
#endif
	__current_set_polling(); //設定本架構下面有標示輪詢poll的bit位，保證cpu進行重新排程。
	arch_cpu_idle_prepare(); //進行idle前的準備工作，ARM64中沒有實現
	per_cpu(idle_force_poll, smp_processor_id()) = 0;
	cpu_idle_loop(); //進入idle程式的事件迴圈
}

複製程式碼

1.13 cpu_idle_loop

定義在msm/kernel/cpu/idle.c中

/*
 * Generic idle loop implementation
 */
static void cpu_idle_loop(void)
{
	while (1) { //開啟無限迴圈，進行程式排程
		tick_nohz_idle_enter(); //停止週期時鐘

		while (!need_resched()) { //判斷是否有設定TIF_NEED_RESCHED，只有系統沒有程式需要排程時才執行while裡面操作
			check_pgt_cache();
			rmb();

			local_irq_disable(); //關閉irq中斷
			arch_cpu_idle_enter();

			/*
			 * In poll mode we reenable interrupts and spin.
			 *
			 * Also if we detected in the wakeup from idle
			 * path that the tick broadcast device expired
			 * for us, we don't want to go deep idle as we
			 * know that the IPI is going to arrive right
			 * away
			 */
			if (cpu_idle_force_poll ||
			    tick_check_broadcast_expired() ||
			    __get_cpu_var(idle_force_poll)) {
				cpu_idle_poll(); //進入 CPU 的poll mode模式，避免進入深度睡眠，可以處理 處理器間中斷
			} else {
				if (!current_clr_polling_and_test()) {
					stop_critical_timings();
					rcu_idle_enter();
					arch_cpu_idle(); //進入 CPU 的 idle 模式，省電
					WARN_ON_ONCE(irqs_disabled());
					rcu_idle_exit();
					start_critical_timings();
				} else {
					local_irq_enable();
				}
				__current_set_polling();
			}
			arch_cpu_idle_exit();
		}
		tick_nohz_idle_exit(); //如果有程式需要排程，則先開啟週期時鐘
		schedule_preempt_disabled(); //讓出cpu，執行排程
		if (cpu_is_offline(smp_processor_id())) //如果當前cpu處理offline狀態，關閉idle程式
			arch_cpu_idle_dead();

	}
}
複製程式碼

idle程式並不執行什麼複雜的工作，只有在系統沒有其他程式排程的時候才進入idle程式，而在idle程式中儘可能讓cpu空閒下來，連週期時鐘也關掉了，達到省電目的。當有其他程式需要排程的時候，馬上開啟週期時鐘，然後讓出cpu。

小結

idle程式是Linux系統的第一個程式，程式號是0，在完成系統環境初始化工作之後，開啟了兩個重要的程式，init程式和kthreadd程式，執行完建立工作之後，開啟一個無限迴圈，負責程式的排程。

二、kthreadd程式啟動

之前在rest_init函式中啟動了kthreadd程式

pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
複製程式碼

程式建立成功後會執行kthreadd函式

2.1 kthreadd

定義在msm/kernel/kthread.c中

int kthreadd(void *unused)
{
	struct task_struct *tsk = current;

	/* Setup a clean context for our children to inherit. */
	set_task_comm(tsk, "kthreadd");
	ignore_signals(tsk);
	set_cpus_allowed_ptr(tsk, cpu_all_mask); //  允許kthreadd在任意CPU上執行
	set_mems_allowed(node_states[N_MEMORY]);

	current->flags |= PF_NOFREEZE;

	for (;;) {
		set_current_state(TASK_INTERRUPTIBLE); //首先將執行緒狀態設定為 TASK_INTERRUPTIBLE, 
		//如果當前沒有要建立的執行緒則主動放棄 CPU 完成排程.此程式變為阻塞態
		
		if (list_empty(&kthread_create_list)) //  沒有需要建立的核心執行緒
			schedule(); //   執行一次排程, 讓出CPU
		__set_current_state(TASK_RUNNING);//  執行到此表示 kthreadd 執行緒被喚醒(就是我們當前),設定程式執行狀態為 TASK_RUNNING
		spin_lock(&kthread_create_lock); //spin_lock和spin_unlock是配套的加鎖機制，spin_lock是加鎖
		while (!list_empty(&kthread_create_list)) {
			struct kthread_create_info *create;

			create = list_entry(kthread_create_list.next,
					    struct kthread_create_info, list); //kthread_create_list是一個連結串列，
					    //從連結串列中取出下一個要建立的kthread_create_info,即執行緒建立資訊
					    
			list_del_init(&create->list); //刪除create中的list
			spin_unlock(&kthread_create_lock); //解鎖

			create_kthread(create); //建立執行緒

			spin_lock(&kthread_create_lock); 
		}
		spin_unlock(&kthread_create_lock);
	}

	return 0;
}
複製程式碼

kthreadd函式的作用就是迴圈地從kthread_create_list連結串列中取出要建立的執行緒，然後執行create_kthread函式，直到kthread_create_list為空，讓出CPU,進入睡眠，我們來看下create_kthread函式

2.2 create_kthread

定義在msm/kernel/kthread.c中

static void create_kthread(struct kthread_create_info *create)
{
	int pid;

#ifdef CONFIG_NUMA
	current->pref_node_fork = create->node;
#endif
	/* We want our own signal handler (we take no signals by default). */
	pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
	if (pid < 0) {
		create->result = ERR_PTR(pid);
		complete(&create->done);
	}
}
複製程式碼

其實這裡面就是呼叫kernel_thread函式建立程式，然後執行kthread函式，注意不要搞混了，之前那個函式叫kthreadd，接下來看看kthread函式

2.3 kthread

定義在msm/kernel/kthread.c中

static int kthread(void *_create)
{
	/* Copy data: it's on kthread's stack */
	struct kthread_create_info *create = _create;  // create 就是之前kthreadd函式迴圈取出的 kthread_create_info
	int (*threadfn)(void *data) = create->threadfn; //新執行緒工作函式
	void *data = create->data;
	struct kthread self;
	int ret;

	self.flags = 0;
	self.data = data;
	init_completion(&self.exited);
	init_completion(&self.parked);
	current->vfork_done = &self.exited;

	/* OK, tell user we're spawned, wait for stop or wakeup */
	__set_current_state(TASK_UNINTERRUPTIBLE);
	create->result = current;
	complete(&create->done); //表示執行緒建立完畢
	schedule(); //讓出CPU，注意這裡並沒有執行新執行緒的threadfn函式就直接進入睡眠了，然後等待執行緒被手動喚醒，然後才執行threadfn

	ret = -EINTR;

	if (!test_bit(KTHREAD_SHOULD_STOP, &self.flags)) {
		__kthread_parkme(&self);
		ret = threadfn(data);
	}
	/* we can't just return, we must preserve "self" on stack */
	do_exit(ret);
}
複製程式碼

2.4 kthread_create & kthread_run

定義在msm/include/linux/kthread.h

kthreadd建立執行緒是遍歷kthread_create_list列表，那kthread_create_list列表中的值是哪兒來的呢？我們知道Linux建立核心執行緒有兩種方式，kthread_create和kthread_run

#define kthread_create(threadfn, data, namefmt, arg...) \
	kthread_create_on_node(threadfn, data, -1, namefmt, ##arg)

#define kthread_run(threadfn, data, namefmt, ...)			   \
({									   \
	struct task_struct *__k						   \
		= kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \
	if (!IS_ERR(__k))						   \
		wake_up_process(__k);	//手動喚醒新執行緒				   \
	__k;								   \
})
複製程式碼

kthread_create和kthread_run並不是函式，而是巨集，巨集相當於Java中的final static定義，在編譯時會替換對應程式碼，巨集的引數沒有型別定義，多行巨集的定義會在行末尾加上\

這兩個巨集最終都是呼叫kthread_create_on_node函式，只是kthread_run線上程建立完成後會手動喚醒，我們來看看kthread_create_on_node函式

2.5 kthread_create_on_node

定義在msm/kernel/kthread.c中

/**
 * kthread_create_on_node - create a kthread.
 * @threadfn: the function to run until signal_pending(current).
 * @data: data ptr for @threadfn.
 * @node: memory node number.
 * @namefmt: printf-style name for the thread.
 *
 * Description: This helper function creates and names a kernel
 * thread.  The thread will be stopped: use wake_up_process() to start
 * it.  See also kthread_run().
 *
 * If thread is going to be bound on a particular cpu, give its node
 * in @node, to get NUMA affinity for kthread stack, or else give -1.
 * When woken, the thread will run @threadfn() with @data as its
 * argument. @threadfn() can either call do_exit() directly if it is a
 * standalone thread for which no one will call kthread_stop(), or
 * return when 'kthread_should_stop()' is true (which means
 * kthread_stop() has been called).  The return value should be zero
 * or a negative error number; it will be passed to kthread_stop().
 *
 * Returns a task_struct or ERR_PTR(-ENOMEM).
 */
struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
					   void *data, int node,
					   const char namefmt[],
					   ...)
{
	struct kthread_create_info create;

	create.threadfn = threadfn;
	create.data = data;
	create.node = node;
	init_completion(&create.done);  //初始化&create.done，之前講過completion和wait_for_completion同步

	spin_lock(&kthread_create_lock);  //加鎖，之前也講過
	list_add_tail(&create.list, &kthread_create_list);  //將要建立的執行緒加到kthread_create_list連結串列尾部
	spin_unlock(&kthread_create_lock);

	wake_up_process(kthreadd_task);  //喚醒kthreadd程式，開啟列表迴圈建立執行緒
	wait_for_completion(&create.done);  //當&create.done complete時，會繼續往下執行

	if (!IS_ERR(create.result)) {
		static const struct sched_param param = { .sched_priority = 0 };
		va_list args;  //不定引數定義，相當於Java中的... ，定義多個數量不定的引數

		va_start(args, namefmt);
		vsnprintf(create.result->comm, sizeof(create.result->comm),
			  namefmt, args);
		va_end(args);
		/*
		 * root may have changed our (kthreadd's) priority or CPU mask.
		 * The kernel thread should not inherit these properties.
		 */
		sched_setscheduler_nocheck(create.result, SCHED_NORMAL, &param);  //create.result型別為task_struct，
		//該函式作用是設定新執行緒排程策略，SCHED_NORMAL 普通排程策略，非實時，
		//優先順序低於實時排程策略SCHED_FIFO和SCHED_RR，param的優先順序上面定義為0
		
		set_cpus_allowed_ptr(create.result, cpu_all_mask); //允許新執行緒在任意CPU上執行
	}
	return create.result;
}
複製程式碼

kthread_create_on_node主要作用就是在kthread_create_list連結串列尾部加上要建立的執行緒，然後喚醒kthreadd程式進行具體建立工作

小結

kthreadd程式由idle通過kernel_thread建立，並始終執行在核心空間, 負責所有核心執行緒的排程和管理，所有的核心執行緒都是直接或者間接的以kthreadd為父程式。

• kthreadd程式會執行一個kthreadd的函式，該函式的作用就是遍歷kthread_create_list連結串列，從連結串列中取出需要建立的核心執行緒進行建立, 建立成功後會執行kthread函式。

• kthread函式完成一些初始賦值後就讓出CPU，並沒有執行新執行緒的工作函式，因此需要手工 wake up被喚醒後，新執行緒才執行自己的真正工作函式。

• 當我們呼叫kthread_create和kthread_run建立的核心執行緒會被加入到kthread_create_list連結串列，kthread_create不會手動wake up新執行緒，kthread_run會手動wake up新執行緒。

其實這就是一個典型的生產者消費者模式，kthread_create和kthread_run負責生產各種核心執行緒建立需求，kthreadd開啟迴圈去消費各種核心執行緒建立需求。

三、init程式啟動

init程式分為前後兩部分，前一部分是在核心啟動的，主要是完成建立和核心初始化工作，內容都是跟Linux核心相關的;後一部分是在使用者空間啟動的，主要完成Android系統的初始化工作。

我這裡要講的是前一部分，後一部分將在下一篇文章中講述。

之前在rest_init函式中啟動了init程式

kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
複製程式碼

在建立完init程式後，會呼叫kernel_init函式

3.1 kernel_init

定義在msm/init/main.c中

/*
 * __ref 這個跟之前講的__init作用一樣
 */
static int __ref kernel_init(void *unused)
{
	kernel_init_freeable(); //進行init程式的一些初始化操作
	/* need to finish all async __init code before freeing the memory */
	async_synchronize_full();// 等待所有非同步呼叫執行完成,，在釋放記憶體前，必須完成所有的非同步 __init 程式碼
	free_initmem();// 釋放所有init.* 段中的記憶體
	mark_rodata_ro(); //arm64空實現
	system_state = SYSTEM_RUNNING;// 設定系統狀態為執行狀態
	numa_default_policy(); // 設定NUMA系統的預設記憶體訪問策略

	flush_delayed_fput(); // 釋放所有延時的struct file結構體

	if (ramdisk_execute_command) { //ramdisk_execute_command的值為"/init"
		if (!run_init_process(ramdisk_execute_command)) //執行根目錄下的init程式
			return 0;
		pr_err("Failed to execute %s\n", ramdisk_execute_command);
	}

	/*
	 * We try each of these until one succeeds.
	 *
	 * The Bourne shell can be used instead of init if we are
	 * trying to recover a really broken machine.
	 */
	if (execute_command) { //execute_command的值如果有定義就去根目錄下找對應的應用程式,然後啟動
		if (!run_init_process(execute_command))
			return 0;
		pr_err("Failed to execute %s.  Attempting defaults...\n",
			execute_command);
	}
	if (!run_init_process("/sbin/init") || //如果ramdisk_execute_command和execute_command定義的應用程式都沒有找到，
	//就到根目錄下找 /sbin/init，/etc/init，/bin/init,/bin/sh 這四個應用程式進行啟動
	
	    !run_init_process("/etc/init") ||
	    !run_init_process("/bin/init") ||
	    !run_init_process("/bin/sh"))
		return 0;

	panic("No init found.  Try passing init= option to kernel. "
	      "See Linux Documentation/init.txt for guidance.");
}
複製程式碼

kernel_init主要工作是完成一些init的初始化操作，然後去系統根目錄下依次找ramdisk_execute_command和execute_command設定的應用程式，如果這兩個目錄都找不到，就依次去根目錄下找 /sbin/init，/etc/init，/bin/init,/bin/sh 這四個應用程式進行啟動，只要這些應用程式有一個啟動了，其他就不啟動了

ramdisk_execute_command和execute_command的值是通過bootloader傳遞過來的引數設定的，ramdisk_execute_command通過"rdinit"引數賦值，execute_command通過"init"引數賦值

ramdisk_execute_command如果沒有被賦值，kernel_init_freeable函式會賦一個初始值"/init"

3.2 kernel_init_freeable

定義在msm/init/main.c中

static noinline void __init kernel_init_freeable(void)
{
	/*
	 * Wait until kthreadd is all set-up.
	 */
	wait_for_completion(&kthreadd_done); //等待&kthreadd_done這個值complete,這個在rest_init方法中有寫，在ktreadd程式啟動完成後設定為complete

	/* Now the scheduler is fully set up and can do blocking allocations */
	gfp_allowed_mask = __GFP_BITS_MASK;//設定bitmask, 使得init程式可以使用PM並且允許I/O阻塞操作

	/*
	 * init can allocate pages on any node
	 */
	set_mems_allowed(node_states[N_MEMORY]);//init程式可以分配物理頁面
	/*
	 * init can run on any cpu.
	 */
	set_cpus_allowed_ptr(current, cpu_all_mask); //init程式可以在任意cpu上執行

	cad_pid = task_pid(current); //設定到init程式的pid號給cad_pid，cad就是ctrl-alt-del，設定init程式來處理ctrl-alt-del訊號

	smp_prepare_cpus(setup_max_cpus);//設定smp初始化時的最大CPU數量，然後將對應數量的CPU狀態設定為present

	do_pre_smp_initcalls();//呼叫__initcall_start到__initcall0_start之間的initcall_t函式指標
	lockup_detector_init(); //開啟watchdog_threads，watchdog主要用來監控、管理CPU的執行狀態

	smp_init();//啟動cpu0外的其他cpu核
	sched_init_smp(); //程式排程域初始化

	do_basic_setup();//初始化裝置，驅動等，這個方法比較重要，將在下面單獨講

	/* Open the /dev/console on the rootfs, this should never fail */
	if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) // 開啟/dev/console，
	//檔案號0，作為init程式標準輸入
	
		pr_err("Warning: unable to open an initial console.\n");

	(void) sys_dup(0);// 標準輸入
	(void) sys_dup(0);// 標準輸出
	/*
	 * check if there is an early userspace init.  If yes, let it do all
	 * the work
	 */

	if (!ramdisk_execute_command)  //如果 ramdisk_execute_command 沒有賦值，則賦值為"/init"，之前有講到
		ramdisk_execute_command = "/init";

	if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { 
	// 嘗試進入ramdisk_execute_command指向的檔案，如果失敗則重新掛載根檔案系統
	
		ramdisk_execute_command = NULL;
		prepare_namespace();
	}

	/*
	 * Ok, we have completed the initial bootup, and
	 * we're essentially up and running. Get rid of the
	 * initmem segments and start the user-mode stuff..
	 */

	/* rootfs is available now, try loading default modules */
	load_default_modules(); // 載入I/O排程的電梯演算法
}

複製程式碼

kernel_init_freeable函式做了很多重要的事情

• 啟動了smp，smp全稱是Symmetrical Multi-Processing，即對稱多處理，是指在一個計算機上彙集了一組處理器(多CPU),各CPU之間共享記憶體子系統以及匯流排結構。
• 初始化裝置和驅動程式
• 開啟標準輸入和輸出
• 初始化檔案系統

3.3 do_basic_setup

定義在msm/init/main.c中

/*
 * Ok, the machine is now initialized. None of the devices
 * have been touched yet, but the CPU subsystem is up and
 * running, and memory and process management works.
 *
 * Now we can finally start doing some real work..
 */
static void __init do_basic_setup(void)
{
	cpuset_init_smp();//針對SMP系統，初始化核心control group的cpuset子系統。
	usermodehelper_init();// 建立khelper單執行緒工作佇列，用於協助新建和執行使用者空間程式
	shmem_init();// 初始化共享記憶體
	driver_init();// 初始化裝置驅動，比較重要下面單獨講
	init_irq_proc();//建立/proc/irq目錄, 並初始化系統中所有中斷對應的子目錄
	do_ctors();// 執行核心的建構函式
	usermodehelper_enable();// 啟用usermodehelper
	do_initcalls();//遍歷initcall_levels陣列，呼叫裡面的initcall函式，這裡主要是對裝置、驅動、檔案系統進行初始化，
	//之所有將函式封裝到陣列進行遍歷，主要是為了好擴充套件
	
	random_int_secret_init();//初始化隨機數生成池
}
複製程式碼

3.4 driver_init

定義在msm/drivers/base/init.c中

/**
 * driver_init - initialize driver model.
 *
 * Call the driver model init functions to initialize their
 * subsystems. Called early from init/main.c.
 */
void __init driver_init(void)
{
	/* These are the core pieces */
	devtmpfs_init();// 註冊devtmpfs檔案系統，啟動kdevtmpfs程式
	devices_init();// 初始化驅動模型中的部分子系統，kset：devices 和 kobject：dev、 dev/block、 dev/char
	buses_init();// 初始化驅動模型中的bus子系統，kset：bus、devices/system
	classes_init();// 初始化驅動模型中的class子系統，kset：class
	firmware_init();// 初始化驅動模型中的firmware子系統 ，kobject：firmware
	hypervisor_init();// 初始化驅動模型中的hypervisor子系統，kobject：hypervisor

	/* These are also core pieces, but must come after the
	 * core core pieces.
	 */
	platform_bus_init();// 初始化驅動模型中的bus/platform子系統,這個節點是所有platform裝置和驅動的匯流排型別，
	//即所有platform裝置和驅動都會掛載到這個匯流排上
	
	cpu_dev_init(); // 初始化驅動模型中的devices/system/cpu子系統,該節點包含CPU相關的屬性
	memory_dev_init();//初始化驅動模型中的/devices/system/memory子系統,該節點包含了記憶體相關的屬性，如塊大小等
}

複製程式碼

這個函式完成驅動子系統的構建，實現了Linux裝置驅動的一個整體框架，但是它只是建立了目錄結構，具體驅動的裝載是在do_initcalls函式，之前有講

kernel_init_freeable函式告一段落了，我們接著講kernel_init中剩餘的函式

3.5 free_initmem

定義在msm/arch/arm64/mm/init.c中中

void free_initmem(void)
{
	poison_init_mem(__init_begin, __init_end - __init_begin);
	free_initmem_default(0);
}
複製程式碼

所有使用__init標記過的函式和使用__initdata標記過的資料，在free_initmem函式執行後，都不能使用，它們曾經獲得的記憶體現在可以重新用於其他目的。

3.6 flush_delayed_fput

定義在msm/arch/arm64/mm/init.c中,它執行的是delayed_fput(NULL)

static void delayed_fput(struct work_struct *unused)
{
	LIST_HEAD(head);
	spin_lock_irq(&delayed_fput_lock);
	list_splice_init(&delayed_fput_list, &head);
	spin_unlock_irq(&delayed_fput_lock);
	while (!list_empty(&head)) {
		struct file *f = list_first_entry(&head, struct file, f_u.fu_list);
		list_del_init(&f->f_u.fu_list); //刪除fu_list
		__fput(f); //釋放struct file
	}
}
複製程式碼

這個函式主要用於釋放&delayed_fput_list這個連結串列中的struct file，struct file即檔案結構體，代表一個開啟的檔案，系統中的每個開啟的檔案在核心空間都有一個關聯的 struct file。

3.7 run_init_process

定義在msm/init/main.c中

static int run_init_process(const char *init_filename)
{
	argv_init[0] = init_filename;
	return do_execve(init_filename,
		(const char __user *const __user *)argv_init,
		(const char __user *const __user *)envp_init); //do_execve就是執行一個可執行檔案
}
複製程式碼

run_init_process就是執行可執行檔案了，從kernel_init函式中可知，系統會依次去找根目錄下的init，execute_command，/sbin/init，/etc/init，/bin/init,/bin/sh這六個可執行檔案，只要找到其中一個，其他就不執行。

Android系統一般會在根目錄下放一個init的可執行檔案，也就是說Linux系統的init程式在核心初始化完成後，就直接執行init這個檔案，這個檔案的原始碼在platform/system/core/init/init.cpp，下一篇文章中我將從這個檔案為入口，講解Android系統的init程式。

關於我

• foxleezh
• 我的部落格
• github
• 郵箱-foxleezh@gmail.com