请教个idle进程的问题。

qxhgd

从网上查了下idle进程和init进程的分析：
init_task是静态制造出来的，pid=0，它试图将从最早的汇编代码一直到start_kernel的执行都纳入到init_task进程上下文中。
请问这句话怎么理解呢？

个人理解：
init_task只是静态的定义了下：
struct task_struct init_task = INIT_TASK(init_task);
EXPORT_SYMBOL(init_task);

最终的执行：
rest_init函数里会调用：

        /* Call into cpu_idle with preempt disabled */
        cpu_idle();

而cpu_idle函数：
void cpu_idle(void)
{
        int cpu = smp_processor_id();

        current_thread_info()->status |= TS_POLLING;

        /* endless idle loop with no priority at all */
        while (1) {
                tick_nohz_stop_sched_tick(1);
                while (!need_resched()) {

                        check_pgt_cache();
                        rmb();

                        if (rcu_pending(cpu))
                                rcu_check_callbacks(cpu, 0);

                        if (cpu_is_offline(cpu))
                                play_dead();

                        local_irq_disable();
                        __get_cpu_var(irq_stat).idle_timestamp = jiffies;
                        /* Don't trace irqs off for idle */
                        stop_critical_timings();
                        pm_idle();
                        start_critical_timings();
                }
                tick_nohz_restart_sched_tick();
                preempt_enable_no_resched();
                schedule();
                preempt_disable();
        }
}

cpu_idle里，执行一个死循环，这里开始执行idle(init_task)了！


ps:linux内核版本号为2.3.27。


不知我的理解是否正确？另外，前面的那句话（试图将从最早的汇编代码一直到start_kernel的执行都纳入到init_task进程上下文中）又如何理解呢？

谢谢！

欢迎各位大侠各抒己见，讨论下！

junnyg

回复 1# qxhgd

个人理解：
start_kernel的最后一步会执行rest_init函数

1. 
   
2. asmlinkage void __init start_kernel(void)
   
3. {
   
4.         ... ...
   
5.         /* Do the rest non-__init'ed, we're now alive */
   
6.         rest_init();
   
7. }
   

复制代码

在rest_init函数中会启动一个内核线程执行kernel_init函数，这个内核线程将成为我们所说的init进程

1. static noinline void __init_refok rest_init(void)
   
2.         __releases(kernel_lock)
   
3. {
   
4.         ... ...
   
5.         kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
   
6.         ... ...
   
7. 
   
8.         /* Call into cpu_idle with preempt disabled */
   
9.         cpu_idle();
   
10. }

复制代码

kernel_init执行initrd的加载，并最终调用initrd中的指向的init程序（默认/init,或者启动参数中加“init=/xxx"指定）

1. 
   
2. static int __init kernel_init(void * unused)
   
3. {
   
4.         ......
   
5.         /*
   
6.          * check if there is an early userspace init.  If yes, let it do all
   
7.          * the work
   
8.          */
   
9. 
   
10.         if (!ramdisk_execute_command)
    
11.                 ramdisk_execute_command = "/init";
    
12. 
    
13.         if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
    
14.                 ramdisk_execute_command = NULL;
    
15.                 prepare_namespace();
    
16.         }
    
17. 
    
18.         /*
    
19.          * Ok, we have completed the initial bootup, and
    
20.          * we're essentially up and running. Get rid of the
    
21.          * initmem segments and start the user-mode stuff..
    
22.          */
    
23. 
    
24.         init_post();
    
25.         return 0;
    
26. }
    
27. /* This is a non __init function. Force it to be noinline otherwise gcc
    
28. * makes it inline to init() and it becomes part of init.text section
    
29. */
    
30. static noinline int init_post(void)
    
31.         __releases(kernel_lock)
    
32. {
    
33.         /* need to finish all async __init code before freeing the memory */
    
34.         async_synchronize_full();
    
35.         free_initmem();
    
36.         unlock_kernel();
    
37.         mark_rodata_ro();
    
38.         system_state = SYSTEM_RUNNING;
    
39.         numa_default_policy();
    
40. 
    
41. 
    
42.         current->signal->flags |= SIGNAL_UNKILLABLE;
    
43. 
    
44.         if (ramdisk_execute_command) {
    
45.                 run_init_process(ramdisk_execute_command);
    
46.                 printk(KERN_WARNING "Failed to execute %s\n",
    
47.                                 ramdisk_execute_command);
    
48.         }
    
49. 
    
50.         /*
    
51.          * We try each of these until one succeeds.
    
52.          *
    
53.          * The Bourne shell can be used instead of init if we are
    
54.          * trying to recover a really broken machine.
    
55.          */
    
56.         if (execute_command) {
    
57.                 run_init_process(execute_command);
    
58.                 printk(KERN_WARNING "Failed to execute %s.  Attempting "
    
59.                                         "defaults...\n", execute_command);
    
60.         }
    
61.         run_init_process("/sbin/init");
    
62.         run_init_process("/etc/init");
    
63.         run_init_process("/bin/init");
    
64.         run_init_process("/bin/sh");
    
65. 
    
66.         panic("No init found.  Try passing init= option to kernel. "
    
67.               "See Linux Documentation/init.txt for guidance.");
    
68. }
    

复制代码

而start_kernle函数的最终流程是调用cpu_idle（）函数进入死循环，成为系统中的idle进程
   

瀚海书香

回复 1# qxhgd
在多处理系统中，每个CPU多有一个进程0。只要打开机器电源，计算机的BIOS就启动某一个cpu，同时禁用其他CPU。运行在CPU0上的swapper进程初始化内核数据结构，然后激活其他CPU，并通过copy_process()函数创建另外的swapper进程，把0传给新创建的swapper进程作为它们新的PID。此外，内核把适当的CPU索引复制给内核所创建的每个进程的thread_info描述符的CPU字段。
CPU的idle进程的创建：

start_kernel-->rest_init-->kernel_init-->smp_init-->cpu_up-->_cpu_up-->__cpu_up-->smp_ops.cpu_up-->native_cpu_up-->__smp_prepare_cpu-->do_warm_boot_cpu-->do_boot_cpu-->alloc_idle_task-->fork_idle-->copy_process

   

junnyg

回复 3# 瀚海书香
每个核都会有一个idle进程，但是init进程只有一个，是由主核启动的，不知道我理解的对吗？


   

瀚海书香

回复 4# junnyg

每个核都会有一个idle进程，但是init进程只有一个，是由主核启动的，不知道我理解的对吗？

可以这么理解。非主核的idle进程，就是init进程运行到最后复制出来的
   

qxhgd

谢各位大侠，受教了！