一、開篇

線程是操作系統的重要組成部件之一，linux內核中，內核線程是如何創建的，在內核啟動過程中，誕生了哪些支撐整個系統運轉的線程，本文將帶著這個疑問瞅一瞅內核源碼，分析內核線程的創建機制。本文基于linux內核版本：4.1.15。

與linux內核1號init進程一樣，在rest_init()函數中將調用kthread_init()函數創建kthreadd線程，如下代碼：

pid=kernel_thread(kthreadd,NULL,CLONE_FS|CLONE_FILES);

下文將看看kthreadd()中完成了哪些事情。

二、kthreadd線程入口分析

kthreadd線程的線程入口為kthreadd（/kernel/kthread.c），如下定義：

intkthreadd(void*unused)
{
structtask_struct*tsk=current;

//該函數會清除當前運行的可執行文件的所有trace，以便啟動一個新的trace
set_task_comm(tsk,"kthreadd");
//忽略tsk的信號
ignore_signals(tsk);
//該行代碼允許kthreadd在任何CPU上運行
set_cpus_allowed_ptr(tsk,cpu_all_mask);
//設置由alloc_lock保護的內存空間
set_mems_allowed(node_states[N_MEMORY]);
//設置kthreadd線程不應該被凍結
current->flags|=PF_NOFREEZE;

for(;;){
set_current_state(TASK_INTERRUPTIBLE);
if(list_empty(&kthread_create_list))
schedule();
__set_current_state(TASK_RUNNING);

spin_lock(&kthread_create_lock);
while(!list_empty(&kthread_create_list)){
structkthread_create_info*create;

create=list_entry(kthread_create_list.next,
structkthread_create_info,list);
list_del_init(&create->list);
spin_unlock(&kthread_create_lock);
//該一步是創建內核線程的關鍵
create_kthread(create);

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

return0;
}

上述第3行代碼：使用current獲取線程控制塊。current定義如下(/include/asm-generic/current.h)：

#defineget_current()(current_thread_info()->task)
#definecurrentget_current()

上述代碼中16~36行代碼：for(;;)是kthreadd的核心功能。使用set_current_state(TASK_INTERRUPTIBLE);將當前線程設置為TASK_INTERRUPTIBLE狀態，如果當前沒有要創建的線程（這一步由kthread_create_list實現），則主動調用schedule()執行調度，讓出CPU，這部分由17~19行代碼實現。否則，kthreadd將處于喚醒狀態，那么就會執行對應的線程創建操作，這部分功能由23~34行代碼實現。

上述代碼中，出現了kthread_create_list這個待創建線程的鏈表，定義如下：

staticLIST_HEAD(kthread_create_list);

第26~27行代碼，使用：

create=list_entry(kthread_create_list.next,
structkthread_create_info,list);

從鏈表中取得 kthread_create_info 結構的地址。

第31行代碼使用create_kthread()創建create代表的內核線程。定義如下（/kernel/kernel.c）：

staticvoidcreate_kthread(structkthread_create_info*create)
{
intpid;

#ifdefCONFIG_NUMA
current->pref_node_fork=create->node;
#endif
/*Wewantourownsignalhandler(wetakenosignalsbydefault).*/
pid=kernel_thread(kthread,create,CLONE_FS|CLONE_FILES|SIGCHLD);
if(piddone,NULL);

if(!done){
kfree(create);
return;
}
create->result=ERR_PTR(pid);
complete(done);
}
}

從上述代碼可知，在create_kthread()中創建線程同樣由kernel_thread()函數完成：

pid=kernel_thread(kthread,create,CLONE_FS|CLONE_FILES|SIGCHLD);

可見新創建的線程的入口是kthread，下文將繼續分析該線程函數。

三、kthread分析

該函數定義在（/kernel/kthead.c）中：

staticintkthread(void*_create)
{
//拷貝數據
//將_create代表的kthread_create_info賦值給create
structkthread_create_info*create=_create;
//設置線程執行的函數指針
int(*threadfn)(void*data)=create->threadfn;
void*data=create->data;
structcompletion*done;
structkthreadself;
intret;

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

/*IfuserwasSIGKILLed,Ireleasethestructure.*/
done=xchg(&create->done,NULL);
if(!done){
kfree(create);
do_exit(-EINTR);
}
/*OK,telluserwe'respawned,waitforstoporwakeup*/
/*創建的新的內核線程被置為TASK_UNINTERRUPTIBLE，需要顯式的被喚醒才能運行*/
__set_current_state(TASK_UNINTERRUPTIBLE);
create->result=current;
complete(done);

//運行到此處，線程已經創建完畢，調用schedule執行調度，主動讓出CPU，喚醒的是調用kthread_create函數的進程。
schedule();

//當本線程（創建的線程）被喚醒后，將繼續執行后續代碼
ret=-EINTR;

if(!test_bit(KTHREAD_SHOULD_STOP,&self.flags)){
__kthread_parkme(&self);
ret=threadfn(data);
}
/*wecan'tjustreturn,wemustpreserve"self"onstack*/
do_exit(ret);
}

上述函數中，創建新 thread 的進程恢復運行 kthread_create() 并且返回新創建線程的任務描述符，在創建線程的線程中由于執行了 schedule() 調度，此時并沒有執行。需使用wake_up_process(p)；喚醒新創建的線程，這時候新創建的線程才得以執行。當線程被喚醒后, 會接著執行threadfn(data)（即：對應線程的真正線程函數）（這一點后文會通過實踐加以驗證！）：

if(!test_bit(KTHREAD_SHOULD_STOP,&self.flags)){
__kthread_parkme(&self);
//執行創建線程對應的線程函數，傳入的參數為data
ret=threadfn(data);
}

總結一下，在kthreadd線程函數中，將完成兩件重要的事情：

1、如果kthread_create_list線程創建鏈表為空，則調用schedule()執行線程調度。

2、如果kthread_create_list線程創建鏈表不為空（即需要創建線程），則調用create_kthread()創建內核線程。

（1）動手玩一玩

基于上述分析，本小節對其加以實踐。

image-20230709113909381

重新編譯構建內核后啟動運行，在啟動階段，會打印出下述信息，這屬于正常的預期現象，因為內核在啟動階段會涉及到內核重要線程的創建和運行。例如：

?

接下來以模塊方式設計兩份代碼：

（1）module_1.c：使用kthread_create()創建一個名為my_thread的線程，在線程執行函數中每隔1000ms打印出一行信息：my_thread running。并暴露出對my_thread線程的喚醒接口：

#include
#include
#include
#include
#include
#include

staticstructtask_struct*my_thread;

voidwakeup_mythread(void)
{
//喚醒內核線程
wake_up_process(my_thread);
}
EXPORT_SYMBOL(wakeup_mythread);

intmy_thread_function(void*data){
while(!kthread_should_stop()){
printk("my_threadrunning
");

msleep(1000);
}
return0;
}

staticint__initmodule_1_init(void){
//創建內核線程
my_thread=kthread_create(my_thread_function,NULL,"my_thread");
if(IS_ERR(my_thread)){
printk(KERN_ERR"Failedtocreatekernelthread
");
returnPTR_ERR(my_thread);
}

return0;
}

staticvoid__exitmodule_1_exit(void){
//停止內核線程
kthread_stop(my_thread);
}

module_init(module_1_init);
module_exit(module_1_exit);

MODULE_AUTHOR("iriczhao");
MODULE_LICENSE("GPL");

（2）module_2.c：調用module_1的wakeup_mythread()喚醒my_thread：

#include
#include
#include
#include

externvoidwakeup_mythread(void);

staticintmodule2_init(void)
{
printk("wakeupmythread
");

wakeup_mythread();

return0;
}

staticvoidmodule2_exit(void)
{
printk("module2_exitexiting
");
}

module_init(module2_init);
module_exit(module2_exit);

//定義模塊相關信息
MODULE_AUTHOR("iriczhao");
MODULE_LICENSE("GPL");

將上述兩份代碼以模塊方式構建。

從上圖中可見：在加載module_1的時候，打印出了：

>>>>>>>>>>>>>>>>>>>>>>>>>>kthread>>>>>>>>>>>>>>>>>>>>>>>>

則證明執行kthread()函數創建了my_thread線程，但是該線程并沒有喚醒執行，而由于在kthread()函數中調用schedule()讓出了cpu，故而后面的代碼沒有執行。

當在加載module_2后，則喚醒了my_thread線程，打印出了：

>>>>>>>>>>>>>>>>>>>>>>>>>>I'mrunning>>>>>>>>>>>>>>>>>>>>>>>>

然后執行my_thread的線程函數，每隔一秒打印出：

my_threadrunning

綜上，也驗證了，當在kthread()中調用schedule()時執行線程調度，讓出了cpu，當喚醒創建的線程時，會繼續執行schedule()后面的代碼。

四、總結與補充

（1）kthread_create()函數

通過以上代碼分析，可見最重要的是kthread_create_list這個全局鏈表。當使用kthread_create()函數創建線程時，最終都會將線程相關資源添加到kthread_create_list鏈表中。如下代碼(/include/linux/kthread.h)：

#definekthread_create(threadfn,data,namefmt,arg...)
kthread_create_on_node(threadfn,data,-1,namefmt,##arg)

由create_kthread()可知，通過kthread_create()入口進來的內核線程創建路徑都具有統一的線程函數kthread（）。

而linux內核的2號線程kthreadd正好負責內核線程的調度和管理。所以說創建的內核線程都是直接或間接的以kthreadd為父進程。

（2）kthread_create與kernel_thread的區別

在（init/mian.c）中，1號init線程和2號kthreadd線程都是通過kernel_thread()函數創建的，那么kernel_thread()后續會調用do_fork()實現線程相關的創建操作。kernel_thread()函數與kthread_create()創建的內核線程有什么區別呢？

1、kthread_create()創建的內核線程有干凈的上下文環境，適合于驅動模塊或用戶空間的程序創建內核線程使用，不會把某些內核信息暴露給用戶空間程序。

2、二者創建的進程的父進程不同： kthread_create()創建的進程的父進程被指定為kthreadd, 而kernel_thread()創建的進程的父進程可以是init或其他內核線程。

（3）kthread_run()函數

kthread_run()函數用于創建并喚醒一個線程，其本質上是調用kthread_create()創建一個線程，并使用wake_up_process()喚醒該線程。定義如下：

#definekthread_run(threadfn,data,namefmt,...)
({
structtask_struct*__k
=kthread_create(threadfn,data,namefmt,##__VA_ARGS__);
if(!IS_ERR(__k))
wake_up_process(__k);
__k;
})

（4）linux內核創建線程的整體過程

綜上，linux內核創建線程的整體過程為：

1、創建kthread_create_info結構，為其分配空間，指定線程函數，線程相關描述數據等。

2、將線程的kthread_create_info結構添加到kthread_create_list全局線程創建鏈表中，并喚醒2號kthreadd線程。

3、2號kthreadd線程將從kthread_create_list全局線程創建鏈表中取出每一個kthread_create_info結構，然后調用create_kthread()函數創建一個線程函數為kthread的線程。在kthread線程函數中將執行創建線程指定的線程函數。

五、附錄

【附錄一】

kthread_create_on_cpu()創建一個綁定CPU的線程：

/**
*kthread_create_on_cpu-Createacpuboundkthread
*@threadfn:thefunctiontorununtilsignal_pending(current).
*@data:dataptrfor@threadfn.
*@cpu:Thecpuonwhichthethreadshouldbebound,
*@namefmt:printf-stylenameforthethread.Formatisrestricted
*to"name.*%u".Codefillsincpunumber.
*
*Description:Thishelperfunctioncreatesandnamesakernelthread
*Thethreadwillbewokenandputintoparkmode.
*/
structtask_struct*kthread_create_on_cpu(int(*threadfn)(void*data),
void*data,unsignedintcpu,
constchar*namefmt)
{
structtask_struct*p;

p=kthread_create_on_node(threadfn,data,cpu_to_node(cpu),namefmt,
cpu);
if(IS_ERR(p))
returnp;
set_bit(KTHREAD_IS_PER_CPU,&to_kthread(p)->flags);
to_kthread(p)->cpu=cpu;
/*ParkthethreadtogetitoutofTASK_UNINTERRUPTIBLEstate*/
kthread_park(p);
returnp;
}

【附錄二】

kthread_create_on_node()函數將操作kthread_create_list鏈表。kthread_create_on_node()函數的功能是：創建kthread，并將其添加到 kthread_create_list線程創建鏈表中，并返回對應的task_struct。

structtask_struct*kthread_create_on_node(int(*threadfn)(void*data),
void*data,intnode,
constcharnamefmt[],
...)
{
DECLARE_COMPLETION_ONSTACK(done);
structtask_struct*task;
structkthread_create_info*create=kmalloc(sizeof(*create),
GFP_KERNEL);

if(!create)
returnERR_PTR(-ENOMEM);
create->threadfn=threadfn;
create->data=data;
create->node=node;
create->done=&done;

spin_lock(&kthread_create_lock);
/*注意這個全局鏈表kthread_create_list，所有通過kthread_create創建的內核線程都會掛在這*/
list_add_tail(&create->list,&kthread_create_list);
spin_unlock(&kthread_create_lock);
/*這是最重要的地方，從代碼看是喚醒了kthreadd_task這個進程，該進程就是內核中的1號進程kthreadd 。因為kthreadd_task在rest_init()中通過find_task_by_pid_ns(pid, &init_pid_ns)；進行了linux內核的早期賦值*/
wake_up_process(kthreadd_task);
/*
*Waitforcompletioninkillablestate,forImightbechosenby
*theOOMkillerwhilekthreaddistryingtoallocatememoryfor
*newkernelthread.
*/
if(unlikely(wait_for_completion_killable(&done))){
/*
*IfIwasSIGKILLedbeforekthreadd(ornewkernelthread)
*callscomplete(),leavethecleanupofthisstructureto
*thatthread.
*/
if(xchg(&create->done,NULL))
returnERR_PTR(-EINTR);
/*
*kthreadd(ornewkernelthread)willcallcomplete()
*shortly.
*/
wait_for_completion(&done);
}
task=create->result;
if(!IS_ERR(task)){
staticconststructsched_paramparam={.sched_priority=0};
va_listargs;

va_start(args,namefmt);
vsnprintf(task->comm,sizeof(task->comm),namefmt,args);
va_end(args);
/*
*rootmayhavechangedour(kthreadd's)priorityorCPUmask.
*Thekernelthreadshouldnotinherittheseproperties.
*/
sched_setscheduler_nocheck(task,SCHED_NORMAL,¶m);
set_cpus_allowed_ptr(task,cpu_all_mask);
}
kfree(create);
returntask;
}

kthread_create_on_node()函數的本質則是創建kthread_create_info結構，并將其添加到kthread_create_list全局鏈表中（/kernel/kthread.h）：

structkthread_create_info
{
/*從kthreadd傳遞給kthread()的信息*/
int(*threadfn)(void*data);
void*data;
intnode;

/*從kthreadd返回給kthread_create()的結果*/
structtask_struct*result;
structcompletion*done;

structlist_headlist;
};

審核編輯：劉清