linux中0號進程的含義是什么

這篇文章主要介紹“linux中0號進程的含義是什么”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“linux中0號進程的含義是什么”文章能幫助大家解決問題。

在linux中，0號進程是指idle進程，是linux啟動的第一個進程；它的task_struct的comm字段為“swapper”，所以也稱為swpper進程。0號進程是唯一一個沒有通過fork或者kernel_thread產生的進程，因為init_task是靜態變量（初始化了的全局變量），其他進程的PCB都是fork或者kernel_thread動態申請內存創建的。

一、0號進程

0號進程，通常也被稱為idle進程，或者也稱為swapper進程。

每個進程都有一個進程控制塊PCB（Process Control Block），PCB的數據結構類型是struct task_struct。idle進程對應的PCB是 struct task_struct init_task。

idle進程是唯一一個沒有通過fork或者kernel_thread產生的進程，因為 init_task 是靜態變量（初始化了的全局變量），其他進程的PCB都是fork或者kernel_thread動態申請內存創建的。

每個進程都有對應的一個函數，idle進程的函數是 start_kernel()，因為進入該函數前，棧指針SP已經指向 init_task 的棧頂了，處于什么進程，看SP指向哪個進程的棧。

0號進程是linux啟動的第一個進程，它的task_struct的comm字段為"swapper",所以也稱為swpper進程。

#define INIT_TASK_COMM "swapper"

當系統中所有的進程起來后，0號進程也就蛻化為idle進程，當一個core上沒有任務可運行時就會去運行idle進程。一旦運行idle進程則此core就可以進入低功耗模式了，在ARM上就是WFI。

我們本節重點關注是0號進程是如何啟動的。在linux內核中為0號進程專門定義了一個靜態的task_struct的結構，稱為init_task。

/*
 * Set up the first task table, touch at your own risk!. Base=0,
 * limit=0x1fffff (=2MB)
 */
struct task_struct init_task
= {
#ifdef CONFIG_THREAD_INFO_IN_TASK
    .thread_info    = INIT_THREAD_INFO(init_task),
    .stack_refcount    = ATOMIC_INIT(1),
#endif
    .state        = 0,
    .stack        = init_stack,
    .usage        = ATOMIC_INIT(2),
    .flags        = PF_KTHREAD,
    .prio        = MAX_PRIO - 20,
    .static_prio    = MAX_PRIO - 20,
    .normal_prio    = MAX_PRIO - 20,
    .policy        = SCHED_NORMAL,
    .cpus_allowed    = CPU_MASK_ALL,
    .nr_cpus_allowed= NR_CPUS,
    .mm        = NULL,
    .active_mm    = &init_mm,
    .tasks        = LIST_HEAD_INIT(init_task.tasks),
    .ptraced    = LIST_HEAD_INIT(init_task.ptraced),
    .ptrace_entry    = LIST_HEAD_INIT(init_task.ptrace_entry),
    .real_parent    = &init_task,
    .parent        = &init_task,
    .children    = LIST_HEAD_INIT(init_task.children),
    .sibling    = LIST_HEAD_INIT(init_task.sibling),
    .group_leader    = &init_task,
    RCU_POINTER_INITIALIZER(real_cred, &init_cred),
    RCU_POINTER_INITIALIZER(cred, &init_cred),
    .comm        = INIT_TASK_COMM,
    .thread        = INIT_THREAD,
    .fs        = &init_fs,
    .files        = &init_files,
    .signal        = &init_signals,
    .sighand    = &init_sighand,
    .blocked    = {{0}},
    .alloc_lock    = __SPIN_LOCK_UNLOCKED(init_task.alloc_lock),
    .journal_info    = NULL,
    INIT_CPU_TIMERS(init_task)
    .pi_lock    = __RAW_SPIN_LOCK_UNLOCKED(init_task.pi_lock),
    .timer_slack_ns = 50000, /* 50 usec default slack */
    .thread_pid    = &init_struct_pid,
    .thread_group    = LIST_HEAD_INIT(init_task.thread_group),
    .thread_node    = LIST_HEAD_INIT(init_signals.thread_head),
};
EXPORT_SYMBOL(init_task);

這個結構體中的成員都是靜態定義了，為了簡單說明，對這個結構做了簡單的刪減。同時我們只關注這個結構中的以下幾個字段，別的先不關注。

• .thread_info = INIT_THREAD_INFO(init_task), 這個結構在thread_info和內核棧的關系中有詳細的描述

• .stack = init_stack, init_stack就是內核棧的靜態的定義

• .comm = INIT_TASK_COMM, 0號進程的名稱。

在這么thread_info和stack都涉及到了Init_stack， 所以先看下init_stack在哪里設置的。

最終發現init_task是在鏈接腳本中定義的。

#define INIT_TASK_DATA(align)                        \
    . = ALIGN(align);                        \
    __start_init_task = .;                        \
    init_thread_union = .;                        \
    init_stack = .;                            \
    KEEP(*(.data..init_task))                    \
    KEEP(*(.data..init_thread_info))                \
    . = __start_init_task + THREAD_SIZE;                \
    __end_init_task = .;

在鏈接腳本中定義了一個INIT_TASK_DATA的宏。

其中__start_init_task就是0號進程的內核棧的基地址，當然了init_thread_union=init_task=__start_init_task的。

而0號進程的內核棧的結束地址等于__start_init_task + THREAD_SIZE， THREAD_SIZE的大小在ARM64一般是16K，或者32K。則__end_init_task就是0號進程的內核棧的結束地址。

idle進程由系統自動創建, 運行在內核態，idle進程其pid=0，其前身是系統創建的第一個進程，也是唯一一個沒有通過fork或者kernel_thread產生的進程。完成加載系統后，演變為進程調度、交換。

二、Linux內核的啟動

熟悉linux內核的朋友都知道，linux內核的啟動 ，一般都是有bootloader來完成裝載，bootloader中會做一些硬件的初始化，然后會跳轉到linux內核的運行地址上去。

如果熟悉ARM架構的盆友也清楚，ARM64架構分為EL0, EL1, EL2, EL3。正常的啟動一般是從高特權模式向低特權模式啟動的。通常來說ARM64是先運行EL3，再EL2，然后從EL2就trap到EL1，也就是我們的Linux內核。

我們來看下Linux內核啟動的代碼。

代碼路徑：arch/arm64/kernel/head.S文件中

/*
 * Kernel startup entry point.
 * ---------------------------
 *
 * The requirements are:
 *   MMU = off, D-cache = off, I-cache = on or off,
 *   x0 = physical address to the FDT blob.
 *
 * This code is mostly position independent so you call this at
 * __pa(PAGE_OFFSET + TEXT_OFFSET).
 *
 * Note that the callee-saved registers are used for storing variables
 * that are useful before the MMU is enabled. The allocations are described
 * in the entry routines.
 */
    /*
     * The following callee saved general purpose registers are used on the
     * primary lowlevel boot path:
     *
     *  Register   Scope                      Purpose
     *  x21        stext() .. start_kernel()  FDT pointer passed at boot in x0
     *  x23        stext() .. start_kernel()  physical misalignment/KASLR offset
     *  x28        __create_page_tables()     callee preserved temp register
     *  x19/x20    __primary_switch()         callee preserved temp registers
     */
ENTRY(stext)
    bl    preserve_boot_args
    bl    el2_setup            // Drop to EL1, w0=cpu_boot_mode
    adrp    x23, __PHYS_OFFSET
    and    x23, x23, MIN_KIMG_ALIGN - 1    // KASLR offset, defaults to 0
    bl    set_cpu_boot_mode_flag
    bl    __create_page_tables
    /*
     * The following calls CPU setup code, see arch/arm64/mm/proc.S for
     * details.
     * On return, the CPU will be ready for the MMU to be turned on and
     * the TCR will have been set.
     */
    bl    __cpu_setup            // initialise processor
    b    __primary_switch
ENDPROC(stext)

上面就是內核在調用start_kernel之前做的主要工作了。

preserve_boot_args用來保留bootloader傳遞的參數，比如ARM上通常的dtb的地址

el2_setup：從注釋上來看是， 用來trap到EL1，說明我們在運行此指令前還在EL2

__create_page_tables： 用來創建頁表，linux才有的是頁面管理物理內存的，在使用虛擬地址之前需要設置好頁面，然后會打開MMU。目前還是運行在物理地址上的

__primary_switch： 主要任務是完成MMU的打開工作

__primary_switch:
    adrp    x1, init_pg_dir
    bl    __enable_mmu
    ldr    x8, =__primary_switched
    adrp    x0, __PHYS_OFFSET
    br    x8
ENDPROC(__primary_switch)

主要是調用__enable_mmu來打開mmu，之后我們訪問的就是虛擬地址了

調用__primary_switched來設置0號進程的運行內核棧，然后調用start_kernel函數

/*
 * The following fragment of code is executed with the MMU enabled.
 *
 *   x0 = __PHYS_OFFSET
 */
__primary_switched:
    adrp    x4, init_thread_union
    add    sp, x4, #THREAD_SIZE
    adr_l    x5, init_task
    msr    sp_el0, x5            // Save thread_info

    adr_l    x8, vectors            // load VBAR_EL1 with virtual
    msr    vbar_el1, x8            // vector table address
    isb

    stp    xzr, x30, [sp, #-16]!
    mov    x29, sp

    str_l    x21, __fdt_pointer, x5        // Save FDT pointer

    ldr_l    x4, kimage_vaddr        // Save the offset between
    sub    x4, x4, x0            // the kernel virtual and
    str_l    x4, kimage_voffset, x5        // physical mappings

    // Clear BSS
    adr_l    x0, __bss_start
    mov    x1, xzr
    adr_l    x2, __bss_stop
    sub    x2, x2, x0
    bl    __pi_memset
    dsb    ishst                // Make zero page visible to PTW

    add    sp, sp, #16
    mov    x29, #0
    mov    x30, #0
    b    start_kernel
ENDPROC(__primary_switched)

init_thread_union就是我們在鏈接腳本中定義的，也就是0號進程的內核棧的棧底

add sp, x4, #THREAD_SIZE： 設置堆棧指針SP的值，就是內核棧的棧底+THREAD_SIZE的大小。現在SP指到了內核棧的頂端

最終通過b start_kernel就跳轉到我們熟悉的linux內核入口處了。　　至此0號進程就已經運行起來了。

三、1號進程

3.1 1號進程的創建

　　當一條b start_kernel指令運行后，內核就開始的內核的全面初始化操作。

asmlinkage __visible void __init start_kernel(void)
{
    char *command_line;
    char *after_dashes;
    set_task_stack_end_magic(&init_task);
    smp_setup_processor_id();
    debug_objects_early_init();
    cgroup_init_early();
    local_irq_disable();
    early_boot_irqs_disabled = true;
    /*
     * Interrupts are still disabled. Do necessary setups, then
     * enable them.
     */
    boot_cpu_init();
    page_address_init();
    pr_notice("%s", linux_banner);
    setup_arch(&command_line);
    /*
     * Set up the the initial canary and entropy after arch
     * and after adding latent and command line entropy.
     */
    add_latent_entropy();
    add_device_randomness(command_line, strlen(command_line));
    boot_init_stack_canary();
    mm_init_cpumask(&init_mm);
    setup_command_line(command_line);
    setup_nr_cpu_ids();
    setup_per_cpu_areas();
    smp_prepare_boot_cpu();    /* arch-specific boot-cpu hooks */
    boot_cpu_hotplug_init();
    build_all_zonelists(NULL);
    page_alloc_init();
    。。。。。。。
    acpi_subsystem_init();
    arch_post_acpi_subsys_init();
    sfi_init_late();
    /* Do the rest non-__init'ed, we're now alive */
    arch_call_rest_init();
}
void __init __weak arch_call_rest_init(void)
{
    rest_init();
}

start_kernel函數就是內核各個重要子系統的初始化，比如mm, cpu, sched, irq等等。最后會調用一個rest_init剩余部分初始化，start_kernel在其最后一個函數rest_init的調用中，會通過kernel_thread來生成一個內核進程，后者則會在新進程環境下調 用kernel_init函數，kernel_init一個讓人感興趣的地方在于它會調用run_init_process來執行根文件系統下的 /sbin/init等程序。

noinline void __ref rest_init(void)
{
    struct task_struct *tsk;
    int pid;
    rcu_scheduler_starting();
    /*
     * 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.
     */
    pid = kernel_thread(kernel_init, NULL, CLONE_FS);
    /*
     * Pin init on the boot CPU. Task migration is not properly working
     * until sched_init_smp() has been run. It will set the allowed
     * CPUs for init to the non isolated CPUs.
     */
    rcu_read_lock();
    tsk = find_task_by_pid_ns(pid, &init_pid_ns);
    set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id()));
    rcu_read_unlock();
    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();
    /*
     * Enable might_sleep() and smp_processor_id() checks.
     * They cannot be enabled earlier because with CONFIG_PREEMPT=y
     * kernel_thread() would trigger might_sleep() splats. With
     * CONFIG_PREEMPT_VOLUNTARY=y the init task might have scheduled
     * already, but it's stuck on the kthreadd_done completion.
     */
    system_state = SYSTEM_SCHEDULING;
    complete(&kthreadd_done);
}

在這個rest_init函數中我們只關系兩點：

• pid = kernel_thread(kernel_init, NULL, CLONE_FS);

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

/*
 * 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, 0);
}

　　很明顯這是創建了兩個內核線程，而kernel_thread最終會調用do_fork根據參數的不同來創建一個進程或者內核線程。關系do_fork的實現我們在后面會做詳細的介紹。當內核線程創建成功后就會調用設置的回調函數。

　　當kernel_thread(kernel_init)成功返回后，就會調用kernel_init內核線程，其實這時候1號進程已經產生了。1號進程的執行函數就是kernel_init, 這個函數被定義init/main.c中，接下來看下kernel_init主要做什么事情。

static int __ref kernel_init(void *unused)
{
    int ret;
    kernel_init_freeable();
    /* need to finish all async __init code before freeing the memory */
    async_synchronize_full();
    ftrace_free_init_mem();
    free_initmem();
    mark_readonly();
    /*
     * Kernel mappings are now finalized - update the userspace page-table
     * to finalize PTI.
     */
    pti_finalize();
    system_state = SYSTEM_RUNNING;
    numa_default_policy();
    rcu_end_inkernel_boot();
    if (ramdisk_execute_command) {
        ret = run_init_process(ramdisk_execute_command);
        if (!ret)
            return 0;
        pr_err("Failed to execute %s (error %d)\n",
               ramdisk_execute_command, ret);
    }
    /*
     * 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) {
        ret = run_init_process(execute_command);
        if (!ret)
            return 0;
        panic("Requested init %s failed (error %d).",
              execute_command, ret);
    }
    if (!try_to_run_init_process("/sbin/init") ||
        !try_to_run_init_process("/etc/init") ||
        !try_to_run_init_process("/bin/init") ||
        !try_to_run_init_process("/bin/sh"))
        return 0;
    panic("No working init found.  Try passing init= option to kernel. "
          "See Linux Documentation/admin-guide/init.rst for guidance.");
}

• kernel_init_freeable函數中就會做各種外設驅動的初始化。

• 最主要的工作就是通過execve執行/init可以執行文件。它按照配置文件/etc/initab的要求，完成系統啟動工作，創建編號為1號、2號...的若干終端注冊進程getty。每個getty進程設置其進程組標識號，并監視配置到系統終端的接口線路。當檢測到來自終端的連接信號時，getty進程將通過函數execve（）執行注冊程序login，此時用戶就可輸入注冊名和密碼進入登錄過程，如果成功，由login程序再通過函數execv（）執行shell，該shell進程接收getty進程的pid，取代原來的getty進程。再由shell直接或間接地產生其他進程。

我們通常將init稱為1號進程，其實在剛才kernel_init的時候1號線程已經創建成功，也可以理解kernel_init是1號進程的內核態，而我們所熟知的init進程是用戶態的，調用execve函數之前屬于內核態，調用之后就屬于用戶態了，執行的代碼段與0號進程不在一樣。

1號內核線程負責執行內核的部分初始化工作及進行系統配置，并創建若干個用于高速緩存和虛擬主存管理的內核線程。

至此1號進程就完美的創建成功了，而且也成功執行了init可執行文件。　　

3.2 init進程

　　隨后，1號進程調用do_execve運行可執行程序init，并演變成用戶態1號進程，即init進程。

　　init進程是linux內核啟動的第一個用戶級進程。init有許多很重要的任務，比如像啟動getty（用于用戶登錄）、實現運行級別、以及處理孤立進程。

　　它按照配置文件/etc/initab的要求，完成系統啟動工作，創建編號為1號、2號…的若干終端注冊進程getty。

　　每個getty進程設置其進程組標識號，并監視配置到系統終端的接口線路。當檢測到來自終端的連接信號時，getty進程將通過函數do_execve（）執行注冊程序login，此時用戶就可輸入注冊名和密碼進入登錄過程，如果成功，由login程序再通過函數execv（）執行shell，該shell進程接收getty進程的pid，取代原來的getty進程。再由shell直接或間接地產生其他進程。

　　上述過程可描述為：0號進程->1號內核進程->1號用戶進程（init進程）->getty進程->shell進程

　　注意，上述過程描述中提到：1號內核進程調用執行init函數并演變成1號用戶態進程（init進程），這里前者是init是函數，后者是進程。兩者容易混淆，區別如下：

• kernel_init函數在內核態運行，是內核代碼

• init進程是內核啟動并運行的第一個用戶進程，運行在用戶態下。

• 一號內核進程調用execve()從文件/etc/inittab中加載可執行程序init并執行，這個過程并沒有使用調用do_fork()，因此兩個進程都是1號進程。

　　當內核啟動了自己之后（已被裝入內存、已經開始運行、已經初始化了所有的設備驅動程序和數據結構等等），通過啟動用戶級程序init來完成引導進程的內核部分。因此，init總是第一個進程（它的進程號總是1）。

　　當init開始運行，它通過執行一些管理任務來結束引導進程，例如檢查文件系統、清理/tmp、啟動各種服務以及為每個終端和虛擬控制臺啟動getty，在這些地方用戶將登錄系統。

　　在系統完全起來之后，init為每個用戶已退出的終端重啟getty（這樣下一個用戶就可以登錄）。init同樣也收集孤立的進程：當一個進程啟動了一個子進程并且在子進程之前終止了，這個子進程立刻成為init的子進程。對于各種技術方面的原因來說這是很重要的，知道這些也是有好處的，因為這便于理解進程列表和進程樹圖。init的變種很少。絕大多數Linux發行版本使用sysinit（由Miguel van Smoorenburg著），它是基于System V的init設計。UNIX的BSD版本有一個不同的init。最主要的不同在于運行級別：System V有而BSD沒有（至少是傳統上說）。這種區別并不是主要的。在此我們僅討論sysvinit。 配置init以啟動getty：/etc/inittab文件。

3.3 init程序

　　1號進程通過execve執行init程序來進入用戶空間，成為init進程，那么這個init在哪里呢

　　內核在幾個位置上來查尋init，這幾個位置以前常用來放置init，但是init的最適當的位置（在Linux系統上）是/sbin/init。如果內核沒有找到init，它就會試著運行/bin/sh，如果還是失敗了，那么系統的啟動就宣告失敗了。

　　因此init程序是一個可以又用戶編寫的進程, 如果希望看init程序源碼的朋友，可以參見。

　　Ubuntu等使用deb包的系統可以通過dpkg -S查看程序所在的包

　　CentOS等使用rpm包的系統可以通過rpm -qf查看系統程序所在的包

四、2號進程

2號進程，也是由0號進程創建的。而且2號進程是所有內核線程父進程。

2號進程就是剛才rest_init中創建的另外一個內核線程。kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);

當kernel_thread(kthreadd)返回時，2號進程已經創建成功了。而且會回調kthreadd函數。

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);
    set_mems_allowed(node_states[N_MEMORY]);
    current->flags |= PF_NOFREEZE;
    cgroup_init_kthreadd();
    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)) {
            struct kthread_create_info *create;
            create = list_entry(kthread_create_list.next,
                        struct kthread_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);
    }
    return 0;
}

這段代碼大概的意思也很簡單明顯；

• 
  

• 設置當前進程的名字為"kthreadd"，也就是task_struct的comm字段

• 然后就是while循環，設置當前的進程的狀態是TASK_INTERRUPTIBLE是可以中斷的

• 判斷kthread_create_list鏈表是不是空，如果是空則就調度出去，讓出cpu

• 如果不是空，則從鏈表中取出一個，然后調用kthread_create去創建一個內核線程。

• 所以說所有的內核線程的父進程都是2號進程，也就是kthreadd。
  

五、總結

linux啟動的第一個進程是0號進程，是靜態創建的，稱為idle進程或者swapper進程。

在0號進程啟動后會接連創建兩個進程，分別是1號進程和2和進程。

1號進程最終會使用execve函數去調用可init可執行文件，init進程最終會去創建所有的應用進程，所以被稱為inti進程。

2號進程會在內核中負責創建所有的內核線程，被稱為kthreadd進程。

所以說0號進程是1號和2號進程的父進程；1號進程是所有用戶態進程的父進程；2號進程是所有內核線程的父進程。

我們通過ps命令就可以詳細的觀察到這一現象。

root@ubuntu:zhuxl$ ps -eF
UID         PID   PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
root          1      0  0 56317  5936   2 Feb16 ?        00:00:04 /sbin/init
root          2      0  0     0     0   1 Feb16 ?        00:00:00 [kthreadd]

上面很清晰的顯示：PID=1的進程是init，PID=2的進程是kthreadd。而他們倆的父進程PPID=0，也就是0號進程。

UID         PID   PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
root          4      2  0     0     0   0 Feb16 ?        00:00:00 [kworker/0:0H]
root          6      2  0     0     0   0 Feb16 ?        00:00:00 [mm_percpu_wq]
root          7      2  0     0     0   0 Feb16 ?        00:00:10 [ksoftirqd/0]
root          8      2  0     0     0   1 Feb16 ?        00:02:11 [rcu_sched]
root          9      2  0     0     0   0 Feb16 ?        00:00:00 [rcu_bh]
root         10      2  0     0     0   0 Feb16 ?        00:00:00 [migration/0]
root         11      2  0     0     0   0 Feb16 ?        00:00:00 [watchdog/0]
root         12      2  0     0     0   0 Feb16 ?        00:00:00 [cpuhp/0]
root         13      2  0     0     0   1 Feb16 ?        00:00:00 [cpuhp/1]
root         14      2  0     0     0   1 Feb16 ?        00:00:00 [watchdog/1]
root         15      2  0     0     0   1 Feb16 ?        00:00:00 [migration/1]
root         16      2  0     0     0   1 Feb16 ?        00:00:11 [ksoftirqd/1]
root         18      2  0     0     0   1 Feb16 ?        00:00:00 [kworker/1:0H]
root         19      2  0     0     0   2 Feb16 ?        00:00:00 [cpuhp/2]
root         20      2  0     0     0   2 Feb16 ?        00:00:00 [watchdog/2]
root         21      2  0     0     0   2 Feb16 ?        00:00:00 [migration/2]
root         22      2  0     0     0   2 Feb16 ?        00:00:11 [ksoftirqd/2]
root         24      2  0     0     0   2 Feb16 ?        00:00:00 [kworker/2:0H]

再來看下，所有內核線性的PPI=2， 也就是所有內核線性的父進程都是kthreadd進程。

UID         PID   PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
root        362      1  0 21574  6136   2 Feb16 ?        00:00:03 /lib/systemd/systemd-journald
root        375      1  0 11906  2760   3 Feb16 ?        00:00:01 /lib/systemd/systemd-udevd
systemd+    417      1  0 17807  2116   3 Feb16 ?        00:00:02 /lib/systemd/systemd-resolved
systemd+    420      1  0 35997   788   3 Feb16 ?        00:00:00 /lib/systemd/systemd-timesyncd
root        487      1  0 43072  6060   0 Feb16 ?        00:00:00 /usr/bin/python3 /usr/bin/networkd-dispatcher --run-startup-triggers
root        489      1  0  8268  2036   2 Feb16 ?        00:00:00 /usr/sbin/cron -f
root        490      1  0  1138   548   0 Feb16 ?        00:00:01 /usr/sbin/acpid
root        491      1  0 106816 3284   1 Feb16 ?        00:00:00 /usr/sbin/ModemManager
root        506      1  0 27628  2132   2 Feb16 ?        00:00:01 /usr/sbin/irqbalance --foreground

所有用戶態的進程的父進程PPID=1，也就是1號進程都是他們的父進程。

關于“linux中0號進程的含義是什么”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。