struct completion {unsigned int done;wait_queue_head_t wait;
};

struct kthread_create_info
{/* Information passed to kthread() from kthreadd. */int (*threadfn)(void *data);void *data;int node;/* Result passed back to kthread_create() from kthreadd. */struct task_struct *result;struct completion done;struct list_head list;
};

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);------------动态初始化完成量spin_lock(&kthread_create_lock);list_add_tail(&create.list, &kthread_create_list);-------------加入链表，相当于把请求挂在一个双向循环链表中spin_unlock(&kthread_create_lock);wake_up_process(kthreadd_task);-----------唤醒处理完成量的内核线程，来处理我们发送的请求wait_for_completion(&create.done);--------等待完成，这个在等待完成量的期间，会导致本进程睡眠。。。。。。。

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;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;
}

static void create_kthread(struct kthread_create_info *create)
{int pid;#ifdef CONFIG_NUMAcurrent->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);-------------------通知请求方，一般就是唤醒了}
}

static noinline void __init_refok rest_init(void)
{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.*/kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);numa_default_policy();pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);------------创建2号进程，也就是kthradd内核线程rcu_read_lock();kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);rcu_read_unlock();complete(&kthreadd_done);------------唤醒被阻塞的进程

在kthreadd 创建之前，

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

也就是说，在2号进程，也就是 kthreadd 被创建好之前，1号进程其实是阻塞的。有一个疑问就是，为什么1号进程要等待2号进程呢？因为假设1号进程不等待，那么用户态进程就可能通过

系统调用来获取资源，而如果这些资源是由2号线程或者2号线程的子线程来维护的话，则必然产生oops。所以这个地方的完成量，起的是一个时序的作用。

 ps -ef |grep -i kthreadd
root         2     0  0 9月15 ?       00:00:00 [kthreadd]

if (!run_init_process("/sbin/init") ||!run_init_process("/etc/init") ||!run_init_process("/bin/init") ||!run_init_process("/bin/sh"))