内核线程的创建和运行

今天药忘吃喽~ 2022-10-09 15:24 114阅读 0赞

上面讲完了用户进程/线程的创建，这里我们看下内核是如何创建线程的。

通过 ps 命令可以看到红色方框标出的都是父进程为2号进程的内核线程，2号进程即蓝色方框标出的进程 kthreadd，1号进程是绿色方框标出的进程 init，它们的父进程号都是0。

![fafbfec3376dd630ab6d98eebfdd95f7.png][]

下面我们一起看下，内核的0号，1号，2号线程的创建过程。

## 0号线程 ##

linux 内核中为0号进程专门定义了一个静态的 task\_struct 的结构，称为 init\_task：

/* include/linux/init_task.h */
    #define INIT_TASK_COMM "swapper"
    
    /* init/init_task.c */
    struct task_struct init_task
    #ifdef CONFIG_ARCH_TASK_STRUCT_ON_STACK
            __init_task_data
    #endif
            __aligned(L1_CACHE_BYTES)
    = {
    #ifdef CONFIG_THREAD_INFO_IN_TASK
            .thread_info    = INIT_THREAD_INFO(init_task),
            .stack_refcount = REFCOUNT_INIT(1),
    #endif
            .state          = 0,
            .stack          = init_stack,
            .usage          = REFCOUNT_INIT(2),
            .flags          = PF_KTHREAD,
            .prio           = MAX_PRIO - 20,
            .static_prio    = MAX_PRIO - 20,
            .normal_prio    = MAX_PRIO - 20,
            .policy         = SCHED_NORMAL,
            .cpus_ptr       = &init_task.cpus_mask,
            .cpus_mask      = CPU_MASK_ALL,
            .nr_cpus_allowed= NR_CPUS,
            .mm             = NULL,
            .active_mm      = &init_mm,
      ......
            .comm           = INIT_TASK_COMM,
            .thread         = INIT_THREAD,
            .fs             = &init_fs,
            .files          = &init_files,
      ......
    };
    EXPORT_SYMBOL(init_task);

这个结构体中的成员都是静态定义的，这里看几个比较重要的变量：

*  .thread\_info = INIT\_THREAD\_INFO(init\_task), 这个结构在 “task\_struct, thread\_info 和内核栈 sp 的关系” 中有详细的描述
 *  .stack = init\_stack, init\_stack 是内核栈的静态定义，定义在链接脚本里

/* include/asm-generic/vmlinux.lds.h */
    #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 = .;

可以看出，\_\_start\_init\_task 是0号进程的内核栈的基地址，\_\_end\_init\_task 是0号进程的内核栈的结束地址。注意：\_\_start\_init\_task = init\_thread\_union = init\_task

*  .comm = INIT\_TASK\_COMM, 0号进程的名称是 swapper

下面结合 Linux 内核启动的部分代码，看下是如何调用 \_\_primary\_switched 来设置0号进程的运行内核栈：

/* arch/arm64/kernel/head.S */
    SYM_FUNC_START_LOCAL(__primary_switched)
            adrp    x4, init_thread_union        ------(1)
            add     sp, x4, #THREAD_SIZE         ------(2)
            adr_l   x5, init_task
            msr     sp_el0, x5                      // Save thread_info
            ......
            b       start_kernel
    SYM_FUNC_END(__primary_switched)             ------(3)

1.  init\_thread\_union 是0号进程的内核栈的基地址
2.  设置堆栈指针 sp 的值，就是内核栈的栈底 + THREAD\_SIZE的大小。现在 sp 指到了内核栈的顶端
3.  跳转到 linux 内核的入口

至此0号进程就已经运行起来了，0号进程，通常也被称为 idle 进程，也称为 swapper 进程。当系统中所有的进程起来后，0号进程也就蜕化为 idle 进程，当一个 CPU 上没有任务可运行时就会去运行 idle 进程。一旦运行 idle 进程，则此 CPU 就可以进入低功耗模式了，在ARM上就是WFI。

## 1号线程 ##

asmlinkage __visible void __init __no_sanitize_address start_kernel(void)
    {
      ......
      arch_call_rest_init();
      ......
    }
    
    void __init __weak arch_call_rest_init(void)
    {
            rest_init();
    }
    
    noinline void __ref rest_init(void)
    {
            struct task_struct *tsk;
            int pid;
    
            rcu_scheduler_starting();
    
            pid = kernel_thread(kernel_init, NULL, CLONE_FS);
    
            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();
    
            system_state = SYSTEM_SCHEDULING;
    
            complete(&kthreadd_done);
    
            schedule_preempt_disabled();
            /* Call into cpu_idle with preempt disabled */
            cpu_startup_entry(CPUHP_ONLINE);
    }

这里会创建1号，2号两个线程：

*  pid = kernel\_thread(kernel\_init, NULL, CLONE\_FS);
 *  pid = kernel\_thread(kthreadd, NULL, CLONE\_FS | CLONE\_FILES);

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, NULL, CLONE\_FS) 返回时，1号进程已经创建成功了。而且会回调 kernel\_init 函数，接下来看下 kernel\_init 主要做什么事情：

static int __ref kernel_init(void *unused)
    {
            int ret;
    
            kernel_init_freeable();
            ......
            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.");
    }

最主要的工作就是通过 execve，执行init可执行文件。init 就是1号线程，它最终会去创建所有的应用进程。确切来讲，init 进程是用户态的，kernel\_init 是1号进程的内核态。

## 2号线程 ##

上面讲到的 kernel\_thread(kthreadd, NULL, CLONE\_FS | CLONE\_FILES) 就是用来创建2号线程，2号线程的执行函数是 kthreadd：

### kthreadd 处理流程 ###

int kthreadd(void *unused)
    {
            struct task_struct *tsk = current;
    
            /* Setup a clean context for our children to inherit. */
            set_task_comm(tsk, "kthreadd");                 ------(1)
            ignore_signals(tsk);
            set_cpus_allowed_ptr(tsk, housekeeping_cpumask(HK_FLAG_KTHREAD));
            set_mems_allowed(node_states[N_MEMORY]);
    
            current->flags |= PF_NOFREEZE;
            cgroup_init_kthreadd();
    
            for (;;) {
                    set_current_state(TASK_INTERRUPTIBLE);  ------(2)
                    if (list_empty(&kthread_create_list))   
                            schedule();                     ------(3)
                    __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);         ------(4)
    
                            spin_lock(&kthread_create_lock);
                    }
                    spin_unlock(&kthread_create_lock);
            }
    
            return 0;
    }

1.  通过设置 task\_struct 的 comm 字段，使当前进程的名字为"kthreadd"
2.  设置当前的进程的状态是 TASK\_INTERRUPTIBLE
3.  如果链表 kthread\_create\_list 是空，说明没有创建内核线程的请求，则直接调用 schedule 进行睡眠
4.  如果不是空，while循环，从链表中取出一个，然后调用 create\_kthread 去创建一个内核线程

所以2号线程 kthreadd 通过 create\_kthread 去创建内核其它的线程，可谓是内核线程的祖先。

至此，我们已经知道 Linux 启动的第一个线程，0号线程是静态创建的。在0号线程启动后会接连创建两个线程，分别是1号线程和2和线程。1号进程最终会去调用可init可执行文件，init进程最终会去创建所有的应用进程。2号进程会在内核中负责创建所有的内核线程。所以说0号进程是1号和2号进程的父进程，1号进程是所有用户态进程的父进程，2号进程是所有内核线程的父进程。

### kthread 处理流程 ###

上面 kthreadd 线程会循环查看链表 kthread\_create\_list，如果有线程的创建申请，则从链表中取出一个，然后调用 create\_kthread 去创建一个内核线程。

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) {
                    /* If user was SIGKILLed, I release the structure. */
                    struct completion *done = xchg(&create->done, NULL);
    
                    if (!done) {
                            kfree(create);
                            return;
                    }
                    create->result = ERR_PTR(pid);
                    complete(done);
            }
    }

可以看出，由 kthreadd 内核线程创建的内核线程的执行函数是 kthread。

static int kthread(void *_create)
    {
            /* Copy data: it's on kthread's stack */
            struct kthread_create_info *create = _create;      ------(1)
            int (*threadfn)(void *data) = create->threadfn;    ------(2)
            void *data = create->data;                         ------(3)
            struct completion *done;
            struct kthread *self;
            int ret;
    
            self = kzalloc(sizeof(*self), GFP_KERNEL);         ------(4)
            set_kthread_struct(self);
    
            /* If user was SIGKILLed, I release the structure. */
            done = xchg(&create->done, NULL);                  ------(5)
            if (!done) {
                    kfree(create);
                    do_exit(-EINTR);
            }
    
            if (!self) {
                    create->result = ERR_PTR(-ENOMEM);
                    complete(done);
                    do_exit(-ENOMEM);
            }
    
            self->threadfn = threadfn;                         ------(6)
            self->data = data;                                 ------(7)
            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);         ------(8)
            create->result = current;                          ------(9)
            /*
             * Thread is going to call schedule(), do not preempt it,
             * or the creator may spend more time in wait_task_inactive().
             */
            preempt_disable();
            complete(done);                                    ------(10)
            schedule_preempt_disabled();                       ------(11)
            preempt_enable();                                  ------(12)
    
            ret = -EINTR;
            if (!test_bit(KTHREAD_SHOULD_STOP, &self->flags)) {------(13)
                    cgroup_kthread_ready();
                    __kthread_parkme(self);
                    ret = threadfn(data);                      ------(14)
            }
            do_exit(ret);                                      ------(15)
    }

1.  取出传递过来的线程创建信息
2.  取出线程执行函数
3.  取出传递给线程执行函数的参数
4.  分配 kthread 结构
5.  获得 done 完成量
6.  赋值 self->threadfn 为线程执行函数
7.  赋值 self->data 为线程执行函数的参数
8.  设置内核线程状态为 TASK\_UNINTERRUPTIBLE，但此时还没有睡眠
9.  用于返回当前任务的 tsk
10. 唤醒等待 done 完成量的任务
11. 睡眠
12. 唤醒的时候从此开始执行
13. 判断 self->flags 是否为 KTHREAD\_SHOULD\_STOP （kthread\_stop 会设置）
14. 执行真正的线程执行函数
15. 退出当前任务

## 内核线程的创建和运行 ##

现在我们知道 kthreadd 会从链表 kthread\_create\_list 中取出一个，然后调用 create\_kthread 去创建一个内核线程。kthreadd 是所有内核线程的父线程，但是子线程如何把请求加入 kthread\_create\_list 链表，如何让子线程运行，还没有深入介绍。

这里举例看一个 peter 线程的创建和运行的简单例子：

int my_kernel_thread(void *arg)  
    {  
     printk("%s: %d\n", __func__);  
     
     return 0;  
    }  
    static int __init test_init_module(void)  
    {  
     printk("%s:\n", __func__);  
     
     peter = kthread_create(my_kernel_thread, NULL, "practice task");  ------(1)
     
     if(!IS_ERR(peter))  
      wake_up_process(peter);                                          ------(2)
     
     return 0;  
    }  
      
    static void __exit test_exit_module(void)  
    {  
     printk("%s:\n", __func__);  
     kthread_stop(peter);  
    }  
      
    module_init(test_init_module);  
    module_exit(test_exit_module);

很简单，通过 kthread\_create 函数创建内核线程，然后通过 wake\_up\_process 唤醒线程，使之运行。

下面我们结合上面的 kthreadd，剖析下内核线程创建和运行的本质。

### kthread\_create ###

kthread\_create 的调用流程是：kthread\_create->kthread\_create\_on\_node->\_\_kthread\_create\_on\_node

struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data),
                                                        void *data, int node,
                                                        const char namefmt[],
                                                        va_list args)
    {
            DECLARE_COMPLETION_ONSTACK(done);                               ------(1)
            struct task_struct *task;
            struct kthread_create_info *create = kmalloc(sizeof(*create),
                                                         GFP_KERNEL);       ------(2)
    
            if (!create)
                    return ERR_PTR(-ENOMEM);
            create->threadfn = threadfn;                                    ------(3)
            create->data = data;
            create->node = node;
            create->done = &done;
    
            spin_lock(&kthread_create_lock);
            list_add_tail(&create->list, &kthread_create_list);             ------(4)
            spin_unlock(&kthread_create_lock);
    
            wake_up_process(kthreadd_task);                                 ------(5)
            /*
             * Wait for completion in killable state, for I might be chosen by
             * the OOM killer while kthreadd is trying to allocate memory for
             * new kernel thread.
             */
            if (unlikely(wait_for_completion_killable(&done))) {            ------(6)
                    /*
                     * If I was SIGKILLed before kthreadd (or new kernel thread)
                     * calls complete(), leave the cleanup of this structure to
                     * that thread.
                     */
                    if (xchg(&create->done, NULL))
                            return ERR_PTR(-EINTR);
                    /*
                     * kthreadd (or new kernel thread) will call complete()
                     * shortly.
                     */
                    wait_for_completion(&done);
            }
            task = create->result;                                          ------(7)
            if (!IS_ERR(task)) {
                    static const struct sched_param param = { .sched_priority = 0 };
                    char name[TASK_COMM_LEN];
    
                    /*
                     * task is already visible to other tasks, so updating
                     * COMM must be protected.
                     */
                    vsnprintf(name, sizeof(name), namefmt, args);
                    set_task_comm(task, name);                              ------(8)
                    /*
                     * root may have changed our (kthreadd's) priority or CPU mask.
                     * The kernel thread should not inherit these properties.
                     */
                    sched_setscheduler_nocheck(task, SCHED_NORMAL, &param); ------(9)
                    set_cpus_allowed_ptr(task,                              ------(10)
                                         housekeeping_cpumask(HK_FLAG_KTHREAD));
            }
            kfree(create);
            return task;
    }

1.  静态定义并初始化一个完成量
2.  分配 kthread\_create\_info 结构
3.  填充 kthread\_create\_info 结构
4.  将 kthread\_create\_info 结构添加到 kthread\_create\_list 链表
5.  唤醒 kthreadd 来处理创建内核线程请求
6.  等待 kthreadd 创建完成这个内核线程
7.  获得创建完成的内核线程的 tsk
8.  设置内核线程的名字
9.  设置调度策略和优先级
10. 设置 CPU 亲和性

### wake\_up\_process ###

上面通过 kthread\_create 分配填充 kthread\_create\_info 结构，然后将该结构添加到 kthread\_create\_list 链表，唤醒 kthreadd 去创建 peter 线程，然后调用 schedule\_preempt\_disabled 使 peter 线程睡眠。等待被 wake\_up\_process 唤醒，一旦执行 wake\_up\_process，则唤醒 peter 线程，去调用它的执行函数 threadfn(data)。

为了更好理解，这里用一张图来总结父线程 kthreadd 和其子线程 peter 的关系：

![92626acb36ea900c9b17b051c901882d.png][]

![虚线阴影分割线][caf5138551d1fa26b44f2b767c554d5c.png]

![379b7de15071647bea4ac71564c67762.png][]

5T技术资源大放送！包括但不限于：C/C++，Arm, Linux，Android，人工智能，单片机，树莓派，等等。在公众号内回复「peter」，即可免费获取！！

![5062ab8eaabc1d4e07ab4b37316539ea.gif][] **记得点击****分享****、****赞****和****在看****，给我充点儿电吧**

[fafbfec3376dd630ab6d98eebfdd95f7.png]: /images/20221005/7c508b6279ec46faabce0a5130108982.png
[92626acb36ea900c9b17b051c901882d.png]: /images/20221005/972c3bfdfcc94096a8d004b40298ae76.png
[caf5138551d1fa26b44f2b767c554d5c.png]: /images/20221005/dfdb07e26e06402a9306a71c4718c58b.png
[379b7de15071647bea4ac71564c67762.png]: /images/20221005/5e3e0889d1f04186954be1df2385be65.png
[5062ab8eaabc1d4e07ab4b37316539ea.gif]: /images/20221005/0ff5249300be4d7ba70f2d55ec387616.png