歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux基礎 >> 關於Linux

Linux下0號進程的前世(init_task進程)今生(idle進程)----Linux進程的管理與調度(五)

Linux下有3個特殊的進程,idle進程(PID = 0), init進程(PID = 1)和kthreadd(PID = 2)


* idle進程由系統自動創建, 運行在內核態

idle進程其pid=0,其前身是系統創建的第一個進程,也是唯一一個沒有通過fork或者kernel_thread產生的進程。完成加載系統後,演變為進程調度、交換


* init進程由idle通過kernel_thread創建,在內核空間完成初始化後, 加載init程序, 並最終用戶空間

由0進程創建,完成系統的初始化. 是系統中所有其它用戶進程的祖先進程
Linux中的所有進程都是有init進程創建並運行的。首先Linux內核啟動,然後在用戶空間中啟動init進程,再啟動其他系統進程。在系統啟動完成完成後,init將變為守護進程監視系統其他進程。


* kthreadd進程由idle通過kernel_thread創建,並始終運行在內核空間, 負責所有內核線程的調度和管理

它的任務就是管理和調度其他內核線程kernel_thread, 會循環執行一個kthread的函數,該函數的作用就是運行kthread_create_list全局鏈表中維護的kthread, 當我們調用kernel_thread創建的內核線程會被加入到此鏈表中,因此所有的內核線程都是直接或者間接的以kthreadd為父進程

我們下面就詳解分析0號進程的前世(init_task)今生(idle)

idle的創建


在smp系統中,每個處理器單元有獨立的一個運行隊列,而每個運行隊列上又有一個idle進程,即有多少處理器單元,就有多少idle進程。

idle進程其pid=0,其前身是系統創建的第一個進程,也是唯一一個沒有通過fork()產生的進程。在smp系統中,每個處理器單元有獨立的一個運行隊列,而每個運行隊列上又有一個idle進程,即有多少處理器單元,就有多少idle進程。系統的空閒時間,其實就是指idle進程的”運行時間”。既然是idle是進程,那我們來看看idle是如何被創建,又具體做了哪些事情?

我們知道系統是從BIOS加電自檢,載入MBR中的引導程序(LILO/GRUB),再加載linux內核開始運行的,一直到指定shell開始運行告一段落,這時用戶開始操作Linux。

0號進程上下文信息–init_task描述符


init_task是內核中所有進程、線程的task_struct雛形,在內核初始化過程中,通過靜態定義構造出了一個task_struct接口,取名為init_task,然後在內核初始化的後期,通過rest_init()函數新建了內核init線程,kthreadd內核線程

內核init線程,最終執行/sbin/init進程,變為所有用戶態程序的根進程(pstree命令顯示),即用戶空間的init進程

開始的init是有kthread_thread創建的內核線程, 他在完成初始化工作後, 轉向用戶空間, 並且生成所有用戶進程的祖先

內核kthreadd內核線程,變為所有內核態其他守護線程的父線程。

它的任務就是管理和調度其他內核線程kernel_thread, 會循環執行一個kthread的函數,該函數的作用就是運行kthread_create_list全局鏈表中維護的kthread, 當我們調用kernel_thread創建的內核線程會被加入到此鏈表中,因此所有的內核線程都是直接或者間接的以kthreadd為父進程

ps-aux

所以init_task決定了系統所有進程、線程的基因, 它完成初始化後, 最終演變為0號進程idle, 並且運行在內核態

內核在初始化過程中,當創建完init和kthreadd內核線程後,內核會發生調度執行,此時內核將使用該init_task作為其task_struct結構體描述符,當系統無事可做時,會調度其執行, 此時該內核會變為idle進程,讓出CPU,自己進入睡眠,不停的循環,查看init_task結構體,其comm字段為swapper,作為idle進程的描述符。

idle的運行時機<喎?http://www.2cto.com/kf/ware/vc/" target="_blank" class="keylink">vcD4NCgk8cD5pZGxlIL34s8zTxc/IvLbOqk1BWF9QUklPLTIwoaPU58/IsOaxvtbQo6xpZGxlyseyztPrtfe2yLXEo6zL+dLUvavG5NPFz8i8tsnotc2146OstbHDu9PQxuTL+734s8y/ydLU1MvQ0Mqxo6yyxbvhtfe2yNa00NAgaWRsZaGjtvjEv8ewtcSw5rG+1tBpZGxlsqKyu9Ta1MvQ0LbTwdDW0LLO0+u197bIo6y2+MrH1NrUy9DQttPB0L3hubnW0LqsaWRsZda41eujrNa4z/JpZGxlvfizzKOs1Nq197bIxve3os/W1MvQ0LbTwdDOqr/VtcTKsbry1MvQ0KOstffI69TL0NA8L3A+DQo8L2Jsb2NrcXVvdGU+DQo8cD688tHU1q4sIDxzdHJvbmc+xNq6y9bQaW5pdF90YXNrseTBv77NysfKx734s8wwyrnTw7XEvfizzMPoyva3+zwvc3Ryb25nPqOs0rLKx0xpbnV4z7XNs9bQtdrSu7j2vfizzMPoyva3+6OsaW5pdF90YXNrsqKyu8rHz7XNs82ouf1rZXJuZWxfdGhyZWFktcS3vcq9o6i1sci7uPyyu7/JxNzKx2ZvcmujqbS0vai1xCwgtvjKx9PJxNq6y7rav82+ssystLS9qLXELjwvcD4NCjxwPrjDvfizzLXEw+jK9rf71NpbaW5pdC9pbml0X3Rhc2tdKDxhIGhyZWY9"http://lxr.free-electrons.com/source/init/init_task.c?v=4.5">http://lxr.free-electrons.com/source/init/init_task.c?v=4.5
)中定義,代碼片段如下

/* Initial task structure */
struct task_struct init_task = INIT_TASK(init_task);
EXPORT_SYMBOL(init_task);

init_task描述符使用宏INIT_TASK對init_task的進程描述符進行初始化,宏INIT_TASK在include/linux/init_task.h文件中

init_task是Linux內核中的第一個線程,它貫穿於整個Linux系統的初始化過程中,該進程也是Linux系統中唯一一個沒有用kernel_thread()函數創建的內核態進程(內核線程)

在init_task進程執行後期,它會調用kernel_thread()函數創建第一個核心進程kernel_init,同時init_task進程繼續對Linux系統初始化。在完成初始化後,init_task會退化為cpu_idle進程,當Core 0的就緒隊列中沒有其它進程時,該進程將會獲得CPU運行。新創建的1號進程kernel_init將會逐個啟動次CPU,並最終創建用戶進程!

備注:core0上的idle進程由init_task進程退化而來,而AP的idle進程則是BSP在後面調用fork()函數逐個創建的

進程堆棧init_thread_union


init_task進程使用init_thread_union數據結構描述的內存區域作為該進程的堆棧空間,並且和自身的thread_info參數公用這一內存空間空間,

請參見 http://lxr.free-electrons.com/source/include/linux/init_task.h?v=4.5

    .stack          = &init_thread_info,

而init_thread_info則是一段體系結構相關的定義,被定義在[/arch/對應體系/include/asm/thread_info.h]中,但是他們大多數為如下定義

#define init_thread_info        (init_thread_union.thread_info)
#define init_stack              (init_thread_union.stack)

其中init_thread_union被定義在init/init_task.c, 緊跟著前面init_task的定義

/*
 * Initial thread structure. Alignment of this is handled by a special
 * linker map entry.
 */
union thread_union init_thread_union __init_task_data =
        { INIT_THREAD_INFO(init_task) };

我們可以發現init_task是用INIT_THREAD_INFO宏進行初始化的, 這個才是我們真正體系結構相關的部分, 他與init_thread_info定義在一起,被定義在/arch/對應體系/include/asm/thread_info.h中,以下為x86架構的定義

參見

http://lxr.free-electrons.com/source/arch/x86/include/asm/thread_info.h?v=4.5

#define INIT_THREAD_INFO(tsk)                   \
{                                               \
    .task           = &tsk,                 \
    .flags          = 0,                    \
    .cpu            = 0,                    \
    .addr_limit     = KERNEL_DS,            \
}

其他體系結構的定義請參見

/arch/對應體系/include/asm/thread_info.h中

架構 定義 x86 arch/x86/include/asm/thread_info.h arm64 arch/arm64/include/asm/thread_info.h

init_thread_info定義中的__init_task_data表明該內核棧所在的區域位於內核映像的init data區,我們可以通過編譯完內核後所產生的System.map來看到該變量及其對應的邏輯地址

cat System.map-3.1.6 | grep init_thread_union

init_thread_union

進程內存空間


init_task的虛擬地址空間,也采用同樣的方法被定義

由於init_task是一個運行在內核空間的內核線程, 因此其虛地址段mm為NULL, 但是必要時他還是需要使用虛擬地址的,因此avtive_mm被設置為init_mm

參見

http://lxr.free-electrons.com/source/include/linux/init_task.h?v=4.5

.mm             = NULL,                                         \
  .active_mm      = &init_mm,                                     \

其中init_mm被定義為init-mm.c中,參見 http://lxr.free-electrons.com/source/mm/init-mm.c?v=4.5

struct mm_struct init_mm = {
    .mm_rb          = RB_ROOT,
    .pgd            = swapper_pg_dir,
    .mm_users       = ATOMIC_INIT(2),
    .mm_count       = ATOMIC_INIT(1),
    .mmap_sem       = __RWSEM_INITIALIZER(init_mm.mmap_sem),
    .page_table_lock =  __SPIN_LOCK_UNLOCKED(init_mm.page_table_lock),
    .mmlist         = LIST_HEAD_INIT(init_mm.mmlist),
    INIT_MM_CONTEXT(init_mm)
};

0號進程的演化


rest_init創建init進程(PID =1)和kthread進程(PID=2)


Linux在無進程概念的情況下將一直從初始化部分的代碼執行到start_kernel,然後再到其最後一個函數調用rest_init

大致是在vmlinux的入口startup_32(head.S)中為pid號為0的原始進程設置了執行環境,然後原是進程開始執行start_kernel()完成Linux內核的初始化工作。包括初始化頁表,初始化中斷向量表,初始化系統時間等。

從rest_init開始,Linux開始產生進程,因為init_task是靜態制造出來的,pid=0,它試圖將從最早的匯編代碼一直到start_kernel的執行都納入到init_task進程上下文中。

這個函數其實是由0號進程執行的, 他就是在這個函數中, 創建了init進程和kthreadd進程

這部分代碼如下:

參見

http://lxr.free-electrons.com/source/init/main.c?v=4.5

static noinline void __init_refok rest_init(void)
{
    int pid;

    rcu_scheduler_starting();
    smpboot_thread_init();

    /*
    * 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.
    */
    kernel_thread(kernel_init, NULL, CLONE_FS);
    numa_default_policy();
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
    rcu_read_lock();
    kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
    rcu_read_unlock();
    complete(&kthreadd_done);

    /*
    * The boot idle thread must execute schedule()
    * at least once to get things moving:
    */
    init_idle_bootup_task(current);
    schedule_preempt_disabled();
    /* Call into cpu_idle with preempt disabled */
    cpu_startup_entry(CPUHP_ONLINE);
}

調用kernel_thread()創建1號內核線程, 該線程隨後轉向用戶空間, 演變為init進程

調用kernel_thread()創建kthreadd內核線程。

init_idle_bootup_task():當前0號進程init_task最終會退化成idle進程,所以這裡調用init_idle_bootup_task()函數,讓init_task進程隸屬到idle調度類中。即選擇idle的調度相關函數。

調用schedule()函數切換當前進程,在調用該函數之前,Linux系統中只有兩個進程,即0號進程init_task和1號進程kernel_init,其中kernel_init進程也是剛剛被創建的。調用該函數後,1號進程kernel_init將會運行!

調用cpu_idle(),0號線程進入idle函數的循環,在該循環中會周期性地檢查。

創建kernel_init


在rest_init函數中,內核將通過下面的代碼產生第一個真正的進程(pid=1):

kernel_thread(kernel_init, NULL, CLONE_FS);

這個進程就是著名的pid為1的init進程,它會繼續完成剩下的初始化工作,然後execve(/sbin/init), 成為系統中的其他所有進程的祖先。

但是這裡我們發現一個問題, init進程應該是一個用戶空間的進程, 但是這裡卻是通過kernel_thread的方式創建的, 哪豈不是式一個永遠運行在內核態的內核線程麼, 它是怎麼演變為真正意義上用戶空間的init進程的?

1號kernel_init進程完成linux的各項配置(包括啟動AP)後,就會在/sbin,/etc,/bin尋找init程序來運行。該init程序會替換kernel_init進程(注意:並不是創建一個新的進程來運行init程序,而是一次變身,使用sys_execve函數改變核心進程的正文段,將核心進程kernel_init轉換成用戶進程init),此時處於內核態的1號kernel_init進程將會轉換為用戶空間內的1號進程init。戶進程init將根據/etc/inittab中提供的信息完成應用程序的初始化調用。然後init進程會執行/bin/sh產生shell界面提供給用戶來與Linux系統進行交互。

調用init_post()創建用戶模式1號進程。

關於init其他的信息我們這次先不研究,因為我們這篇旨在探究0號進程的詳細過程,

創建kthreadd


在rest_init函數中,內核將通過下面的代碼產生第一個kthreadd(pid=2)

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

它的任務就是管理和調度其他內核線程kernel_thread, 會循環執行一個kthread的函數,該函數的作用就是運行kthread_create_list全局鏈表中維護的kthread, 當我們調用kernel_thread創建的內核線程會被加入到此鏈表中,因此所有的內核線程都是直接或者間接的以kthreadd為父進程

0號進程演變為idle


    /*
    * The boot idle thread must execute schedule()
    * at least once to get things moving:
    */
    init_idle_bootup_task(current);
    schedule_preempt_disabled();
    /* Call into cpu_idle with preempt disabled */
    cpu_startup_entry(CPUHP_ONLINE);

因此我們回過頭來看pid=0的進程,在創建了init進程後,pid=0的進程調用 cpu_idle()演變成了idle進程。

0號進程首先執行init_idle_bootup_task, 讓init_task進程隸屬到idle調度類中。即選擇idle的調度相關函數。

這個函數被定義在kernel/sched/core.c中,如下

void init_idle_bootup_task(struct task_struct *idle)
{
    idle->sched_class = &idle_sched_class;
}

接著通過schedule_preempt_disabled來執行調用schedule()函數切換當前進程,在調用該函數之前,Linux系統中只有兩個進程,即0號進程init_task和1號進程kernel_init,其中kernel_init進程也是剛剛被創建的。調用該函數後,1號進程kernel_init將會運行

這個函數被定義在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();
    preempt_disable();
}

最後cpu_startup_entry**調用cpu_idle_loop(),0號線程進入idle函數的循環,在該循環中會周期性地檢查**

cpu_startup_entry定義在kernel/sched/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
    */
#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();
#endif
    arch_cpu_idle_prepare();
    cpu_idle_loop();
}

其中cpu_idle_loop就是idle進程的事件循環,定義在kernel/sched/idle.c

整個過程簡單的說就是,原始進程(pid=0)創建init進程(pid=1),然後演化成idle進程(pid=0)。init進程為每個從處理器(運行隊列)創建出一個idle進程(pid=0),然後演化成/sbin/init。

idle的運行與調度


idle的workload–cpu_idle_loop


從上面的分析我們知道,idle在系統沒有其他就緒的進程可執行的時候才會被調度。不管是主處理器,還是從處理器,最後都是執行的cpu_idle_loop()函數

其中cpu_idle_loop就是idle進程的事件循環,定義在kernel/sched/idle.c,早期的版本中提供的是cpu_idle,但是這個函數是完全依賴於體系結構的,不利用架構的分層,因此在新的內核中更新為更加通用的cpu_idle_loop,由他來調用體系結構相關的代碼

所以我們來看看cpu_idle_loop做了什麼事情。

因為idle進程中並不執行什麼有意義的任務,所以通常考慮的是兩點

節能

低退出延遲。

其代碼如下

/*
 * Generic idle loop implementation
 *
 * Called with polling cleared.
 */
static void cpu_idle_loop(void)
{
        while (1) {
                /*
                 * If the arch has a polling bit, we maintain an invariant:
                 *
                 * Our polling bit is clear if we're not scheduled (i.e. if
                 * rq->curr != rq->idle).  This means that, if rq->idle has
                 * the polling bit set, then setting need_resched is
                 * guaranteed to cause the cpu to reschedule.
                 */

                __current_set_polling();
                quiet_vmstat();
                tick_nohz_idle_enter();

                while (!need_resched()) {
                        check_pgt_cache();
                        rmb();

                        if (cpu_is_offline(smp_processor_id())) {
                                rcu_cpu_notify(NULL, CPU_DYING_IDLE,
                                               (void *)(long)smp_processor_id());
                                smp_mb(); /* all activity before dead. */
                                this_cpu_write(cpu_dead_idle, true);
                                arch_cpu_idle_dead();
                        }

                        local_irq_disable();
                        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())
                                cpu_idle_poll();
                        else
                                cpuidle_idle_call();

                        arch_cpu_idle_exit();
                }

                /*
                 * Since we fell out of the loop above, we know
                 * TIF_NEED_RESCHED must be set, propagate it into
                 * PREEMPT_NEED_RESCHED.
                 *
                 * This is required because for polling idle loops we will
                 * not have had an IPI to fold the state for us.
                 */
                preempt_set_need_resched();
                tick_nohz_idle_exit();
                __current_clr_polling();

                /*
                 * We promise to call sched_ttwu_pending and reschedule
                 * if need_resched is set while polling is set.  That
                 * means that clearing polling needs to be visible
                 * before doing these things.
                 */
                smp_mb__after_atomic();

                sched_ttwu_pending();
                schedule_preempt_disabled();
        }
}

循環判斷need_resched以降低退出延遲,用idle()來節能。

默認的idle實現是hlt指令,hlt指令使CPU處於暫停狀態,等待硬件中斷發生的時候恢復,從而達到節能的目的。即從處理器C0態變到 C1態(見 ACPI標准)。這也是早些年windows平台上各種”處理器降溫”工具的主要手段。當然idle也可以是在別的ACPI或者APM模塊中定義的,甚至是自定義的一個idle(比如說nop)。

  1.idle是一個進程,其pid為0。

  2.主處理器上的idle由原始進程(pid=0)演變而來。從處理器上的idle由init進程fork得到,但是它們的pid都為0。

  3.Idle進程為最低優先級,且不參與調度,只是在運行隊列為空的時候才被調度。

  4.Idle循環等待need_resched置位。默認使用hlt節能。

  希望通過本文你能全面了解linux內核中idle知識。

idle的調度和運行時機


我們知道, linux進程的調度順序是按照 rt實時進程(rt調度器), normal普通進程(cfs調度器),和idel的順序來調度的

那麼可以試想如果rt和cfs都沒有可以運行的任務,那麼idle才可以被調度,那麼他是通過怎樣的方式實現的呢?

由於我們還沒有講解調度器的知識, 所有我們只是簡單講解一下

在normal的調度類,cfs公平調度器sched_fair.c中, 我們可以看到

static const struct sched_class fair_sched_class = {
.next = &idle_sched_class,

也就是說,如果系統中沒有普通進程,那麼會選擇下個調度類優先級的進程,即使用idle_sched_class調度類進行調度的進程

當系統空閒的時候,最後就是調用idle的pick_next_task函數,被定義在/kernel/sched/idle_task.c中

參見

http://lxr.free-electrons.com/source/kernel/sched/idle_task.c?v=4.5

static struct task_struct *pick_next_task_idle(struct rq *rq)
{
        schedstat_inc(rq, sched_goidle);
        calc_load_account_idle(rq);
        return rq->idle;    //可以看到就是返回rq中idle進程。
}

這idle進程在啟動start_kernel函數的時候調用init_idle函數的時候,把當前進程(0號進程)置為每個rq運行隊列的的idle上。

rq->curr = rq->idle = idle;

這裡idle就是調用start_kernel函數的進程,就是0號進程。

idle進程總結


系統允許一個進程創建新進程,新進程即為子進程,子進程還可以創建新的子進程,形成進程樹結構模型。整個linux系統的所有進程也是一個樹形結構。樹根是系統自動構造的(或者說是由內核黑客手動創建的),即在內核態下執行的0號進程,它是所有進程的遠古先祖。

在smp系統中,每個處理器單元有獨立的一個運行隊列,而每個運行隊列上又有一個idle進程,即有多少處理器單元,就有多少idle進程。

idle進程其pid=0,其前身是系統創建的第一個進程(我們稱之為init_task),也是唯一一個沒有通過fork或者kernel_thread產生的進程。

init_task是內核中所有進程、線程的task_struct雛形,它是在內核初始化過程中,通過靜態定義構造出了一個task_struct接口,取名為init_task,然後在內核初始化的後期,在rest_init()函數中通過kernel_thread創建了兩個內核線程內核init線程,kthreadd內核線程, 前者後來通過演變,進入用戶空間,成為所有用戶進程的先祖, 而後者則成為所有內核態其他守護線程的父線程, 負責接手內核線程的創建工作

然後init_task通過變更調度類為sched_idle等操作演變成為idle進程, 此時系統中只有0(idle), 1(init), 2(kthreadd)3個進程, 然後執行一次進程調度, 必然切換當前進程到到init

Copyright © Linux教程網 All Rights Reserved