搜索
bottom↓
回复: 0

《领航者ZYNQ之嵌入式Linux开发指南_V2.0》第十七章 Linux内核启动

[复制链接]

出0入234汤圆

发表于 2022-1-14 18:09:14 | 显示全部楼层 |阅读模式
1)实验平台:正点原子领航者V2 ZYNQ开发板
2)  章节摘自【正点原子】《领航者ZYNQ之嵌入式Linux开发指南_V2.0》
3)购买链接:https://detail.tmall.com/item.htm?id=609032204975
4)全套实验源码+手册+视频下载地址:http://www.openedv.com/thread-329957-1-1.html
5)正点原子官方B站:https://space.bilibili.com/394620890
6)正点原子FPGA技术交流QQ群:90562473
1.png

2.jpg


3.png


第十七章 Linux内核启动流程

       看完Linux内核的顶层Makefile文件以后我们再来看下Linux内核的大致启动流程。Linux内核的启动流程要比uboot复杂的多,涉及到的内容也更多,因此本章我们大致的了解一下Linux内核的启动流程即可。

       1.1链接脚本vmlinux.lds

       要分析Linux启动流程,同样需要先编译一下Linux源码,因为有很多文件是需要编译才会生成的。首先分析Linux内核的连接脚本文件arch/arm/kernel/vmlinux.lds,通过链接脚本可以找到Linux内核的第一行程序是从哪里执行的。vmlinux.lds链接脚本中有如下代码:
  1. 1 OUTPUT_ARCH(arm)
  2. 2 ENTRY(stext)
  3. 3 jiffies = jiffies_64;
  4. 4 SECTIONS
  5. 5 {
  6. 6  /DISCARD/ : {
  7. 7   *(.ARM.exidx.exit.text)
  8. 8   *(.ARM.extab.exit.text)
  9. ……
复制代码
        第2行的ENTRY指明了了Linux内核入口,入口为stext,stext定义在文件arch/arm/kernel/head.S中,因此要分析Linux内核的启动流程,就得先从文件arch/arm/kernel/head.S的stext处开始分析。
        1.2Linux内核启动流程分析
1.2.1Linux内核入口stext

        stext是Linux内核的入口地址,在文件arch/arm/kernel/head.S中有如下所示提示内容:
  1. /*
  2. * Kernel startup entry point.
  3. * ---------------------------
  4. *
  5. * This is normally called from the decompressor code.  The requirements
  6. * are: MMU = off, D-cache = off, I-cache = dont care, r0 = 0,
  7. * r1 = machine nr, r2 = atags or dtb pointer.
  8. .....
  9. */
复制代码
        根据该提示可知Linux内核启动之前要求如下:
        ①、关闭MMU。
        ②、关闭D-cache。
        ③、I-Cache无所谓。
        ④、r0=0。
        ⑤、r1=machine nr(也就是机器ID)。
        ⑥、r2=atags或者设备树(dtb)首地址。
        Linux内核的入口点stext其实相当于内核的入口函数,stext函数内容如下:
  1. 示例代码 17.2.1 arch/arm/kernel/head.S代码段
  2. 80 ENTRY(stext)
  3. ……
  4. 88 #ifdef CONFIG_ARM_VIRT_EXT
  5. 89  bl  __hyp_stub_install
  6. 90 #endif
  7. 91  @ ensure svc mode and all interrupts masked
  8. 92  safe_svcmode_maskall r9
  9. 93
  10. 94  mrc p15, 0, r9, c0, c0      @ get processor id
  11. 95  bl  __lookup_processor_type     @ r5=procinfo r9=cpuid
  12. 96  movs    r10, r5             @ invalid processor (r5=0)?
  13. 97  THUMB( it   eq )        @ force fixup-able long branch encoding
  14. 98  beq __error_p           @ yes, error 'p'
  15. ……
  16. 108 #ifndef CONFIG_XIP_KERNEL
  17. ……
  18. 113 #else
  19. 114     ldr r8, =PLAT_PHYS_OFFSET       @ always constant in this case
  20. 115 #endif
  21. 116
  22. 117     /*
  23. 118      * r1 = machine no, r2 = atags or dtb,
  24. 119      * r8 = phys_offset, r9 = cpuid, r10 = procinfo
  25. 120      */
  26. 121     bl  __vet_atags
  27. 122 #ifdef CONFIG_SMP_ON_UP
  28. 123     bl  __fixup_smp
  29. 124 #endif
  30. 125 #ifdef CONFIG_ARM_PATCH_PHYS_VIRT
  31. 126     bl  __fixup_pv_table
  32. 127 #endif
  33. 128     bl  __create_page_tables
  34. 129
  35. 130     /*
  36. 131      * The following calls CPU specific code in a position independent
  37. 132      * manner.  See arch/arm/mm/proc-*.S for details.  r10 = base of
  38. 133      * xxx_proc_info structure selected by __lookup_processor_type
  39. 134      * above.
  40. 135      *
  41. 136      * The processor init function will be called with:
  42. 137      *  r1 - machine type
  43. 138      *  r2 - boot data (atags/dt) pointer
  44. 139      *  r4 - translation table base (low word)
  45. 140      *  r5 - translation table base (high word, if LPAE)
  46. 141      *  r8 - translation table base 1 (pfn if LPAE)
  47. 142      *  r9 - cpuid
  48. 143      *  r13 - virtual address for __enable_mmu -> __turn_mmu_on
  49. 144      *
  50. 145      * On return, the CPU will be ready for the MMU to be turned on,
  51. 146      * r0 will hold the CPU control register value, r1, r2, r4, and
  52. 147      * r9 will be preserved.  r5 will also be preserved if LPAE.
  53. 148      */
  54. 149     ldr r13, =__mmap_switched      @ address to jump to after
  55. 150                         @ mmu has been enabled
  56. 151     badr    lr, 1f          @ return (PIC) address
  57. 152 #ifdef CONFIG_ARM_LPAE
  58. 153     mov r5, #0              @ high TTBR0
  59. 154     mov r8, r4, lsr #12         @ TTBR1 is swapper_pg_dir pfn
  60. 155 #else
  61. 156     mov r8, r4              @ set TTBR1 to swapper_pg_dir
  62. 157 #endif
  63. 158     ldr r12, [r10, #PROCINFO_INITFUNC]
  64. 159     add r12, r12, r10
  65. 160     ret r12
  66. 161 1:  b   __enable_mmu
  67. 162 ENDPROC(stext)
复制代码
       第88行,如果配置了CONFIG_ARM_VIRT_EXT(ARM虚拟化扩展)则跳转到__hyp_stub_install处。__hyp_stub_install定义在arch\arm\kernel\hyp-stub.S文件中。
       第92行,调用函数safe_svcmode_maskall确保CPU处于SVC模式,并且关闭了所有的中断。safe_svcmode_maskall定义在文件arch/arm/include/asm/assembler.h中。
       第94行,读处理器ID,ID值保存在r9寄存器中。
       第95行,调用函数__lookup_processor_type检查当前系统是否支持此CPU,如果支持的就获取procinfo信息。procinfo是proc_info_list类型的结构体, proc_info_list在文件 arch/arm/include/asm/procinfo.h中的定义如下:
  1. 示例代码 17.2.2 proc_info_list结构体
  2. struct proc_info_list {
  3.     unsigned int                      cpu_val;
  4.     unsigned int                cpu_mask;
  5.     unsigned long               __cpu_mm_mmu_flags;         /* used by head.S */
  6.     unsigned long               __cpu_io_mmu_flags;         /* used by head.S */
  7.     unsigned long               __cpu_flush;                /* used by head.S */
  8.     const char                      *arch_name;
  9.     const char                      *elf_name;
  10.     unsigned int                elf_hwcap;
  11.     const char                      *cpu_name;
  12.     struct processor            *proc;
  13.     struct cpu_tlb_fns          *tlb;
  14.     struct cpu_user_fns         *user;
  15.     struct cpu_cache_fns        *cache;
  16. };
复制代码
       Linux内核将每种处理器都抽象为一个proc_info_list结构体,每种处理器都对应一个procinfo。因此可以通过处理器ID来找到对应的procinfo结构,__lookup_processor_type函数找到对应处理器的procinfo以后会将其保存到r5寄存器中。
       继续回到示例代码 17.2.1中,第121行,调用函数__vet_atags验证atags或设备树(dtb)的合法性。函数__vet_atags定义在文件arch/arm/kernel/head-common.S中。
       第128行,调用函数__create_page_tables创建页表。
       第149行,将函数__mmap_switched的地址保存到r13寄存器中。__mmap_switched定义在文件arch/arm/kernel/head-common.S,__mmap_switched最终会调用start_kernel函数。
       第161行,调用__enable_mmu函数使能MMU,__enable_mmu定义在文件arch/arm/kernel/head.S中。__enable_mmu最终会通过调用__turn_mmu_on来打开MMU,__turn_mmu_on最后会执行r13里面保存的__mmap_switched函数。
1.2.2__mmap_switched函数
        __mmap_switched函数定义在文件arch/arm/kernel/head-common.S中,函数代码如下:
  1. 示例代码 17.2.3 __mmap_switched函数
  2. 81  __mmap_switched:
  3. 82      adr r3, __mmap_switched_data
  4. 83  
  5. 84      ldmia   r3!, {r4, r5, r6, r7}
  6. 85      cmp r4, r5              @ Copy data segment if needed
  7. 86  1:    cmpne   r5, r6
  8. 87      ldrne   fp, [r4], #4
  9. 88      strne   fp, [r5], #4
  10. 89      bne 1b
  11. 90  
  12. 91      mov fp, #0              @ Clear BSS (and zero fp)
  13. 92  1:    cmp r6, r7
  14. 93      strcc   fp, [r6],#4
  15. 94      bcc 1b
  16. 95  
  17. 96   ARM(  ldmia   r3, {r4, r5, r6, r7, sp})
  18. 97   THUMB( ldmia   r3, {r4, r5, r6, r7}    )
  19. 98   THUMB( ldr sp, [r3, #16]       )
  20. 99      str r9, [r4]            @ Save processor ID
  21. 100     str r1, [r5]            @ Save machine type
  22. 101     str r2, [r6]            @ Save atags pointer
  23. 102     cmp r7, #0
  24. 103     strne   r0, [r7]            @ Save control register values
  25. 104     b   start_kernel
  26. 105 ENDPROC(__mmap_switched)
复制代码
       第104行最终调用start_kernel来启动Linux内核,start_kernel函数定义在文件init/main.c中。
1.2.3start_kernel函数
       start_kernel通过调用众多的子函数来完成Linux启动之前的一些初始化工作,由于start_kernel函数里面调用的子函数太多,而这些子函数又很复杂,因此我们简单的来看一下一些重要的子函数。精简并添加注释后的start_kernel函数内容如下:
  1. 示例代码 17.2.4 start_kernel函数
  2. asmlinkage __visible void __init start_kernel(void)
  3. {
  4.     char *command_line;
  5.     char *after_dashes;

  6. set_task_stack_end_magic(&init_task);/* 设置任务栈结束魔术数,用于栈溢出检测 */
  7.     smp_setup_processor_id();   /* 跟SMP有关(多核处理器),设置处理器ID。
  8.                                       * 有很多资料说ARM架构下此函数为空函数,那是因
  9.                                       * 为他们用的老版本Linux,而那时候ARM还没有多
  10.                                       * 核处理器。
  11. */
  12.     debug_objects_early_init();         /* 做一些和debug有关的初始化 */
  13.     cgroup_init_early();         /* cgroup初始化,cgroup用于控制Linux系统资源*/
  14.     local_irq_disable();        /* 关闭当前CPU中断 */
  15.     early_boot_irqs_disabled = true;

  16.     /*
  17.      * 中断关闭期间做一些重要的操作,然后打开中断
  18.      */
  19.     boot_cpu_init();                    /* 跟CPU有关的初始化 */
  20.     page_address_init();                /* 页地址相关的初始化 */
  21.     pr_notice("%s", linux_banner);/* 打印Linux版本号、编译时间等信息 */
  22.     setup_arch(&command_line);  /* 架构相关的初始化,此函数会解析传递进来的        
  23.                                       * ATAGS或者设备树(DTB)文件。会根据设备树里面
  24.                                       * 的model和compatible这两个属性值来查找
  25.                                       * Linux是否支持这个单板。此函数也会获取设备树
  26.                                       * 中chosen节点下的bootargs属性值来得到命令
  27.                                       * 行参数,也就是uboot中的bootargs环境变量的
  28. * 值,获取到的命令行参数会保存到
  29. *command_line中。
  30.                                       */
  31.     mm_init_cpumask(&init_mm);         /* 看名字,应该是和内存有关的初始化 */
  32.     setup_command_line(command_line);   /* 好像是存储命令行参数 */
  33.     setup_nr_cpu_ids();             /* 如果只是SMP(多核CPU)的话,此函数用于获取
  34.                                          * CPU核心数量,CPU数量保存在变量
  35.                                          * nr_cpu_ids中。
  36. */
  37.     setup_per_cpu_areas(); /* 在SMP系统中有用,设置每个CPU的per-cpu数据 */
  38. boot_cpu_state_init();   
  39. smp_prepare_boot_cpu();     

  40.     build_all_zonelists(NULL, NULL);         /* 建立系统内存页区(zone)链表 */
  41.     page_alloc_init();                          /* 处理用于热插拔CPU的页 */

  42. /* 打印命令行信息 */   
  43. pr_notice("Kernel command line: %s\n", boot_command_line);
  44.     parse_early_param();            /* 解析命令行中的console参数 */
  45.     after_dashes = parse_args("Booting kernel",
  46.                   static_command_line, __start___param,
  47.                   __stop___param - __start___param,
  48.                   -1, -1, &unknown_bootoption);
  49.     if (!IS_ERR_OR_NULL(after_dashes))
  50.         parse_args("Setting init args", after_dashes, NULL, 0, -1, -1,
  51.                set_init_arg);

  52.     jump_label_init();

  53.     setup_log_buf(0);                        /* 设置log使用的缓冲区*/
  54.     pidhash_init();           /* 构建PID哈希表,Linux中每个进程都有一个ID,
  55.                                   * 这个ID叫做PID。通过构建哈希表可以快速搜索进程
  56.                                   * 信息结构体。
  57.                                   */
  58. vfs_caches_init_early();        /* 预先初始化vfs(虚拟文件系统)的目录项和索引节点缓存*/
  59.     sort_main_extable();                /* 定义内核异常列表 */
  60.     trap_init();                        /* 完成对系统保留中断向量的初始化 */
  61.     mm_init();                                 /* 内存管理初始化 */

  62.     sched_init();                       /* 初始化调度器,主要是初始化一些结构体 */
  63.     preempt_disable();                  /* 关闭优先级抢占 */
  64.     if (WARN(!irqs_disabled(),          /* 检查中断是否关闭,如果没有的话就关闭中断 */
  65.          "Interrupts were enabled *very* early, fixing it\n"))
  66.         local_irq_disable();
  67. radix_tree_init();
  68. workqueue_init_early(); /*允许及早创建工作队列和工作项排队/取消。工作项的执行取决于kthread,并在workqueue_init()之后开始。*/
  69. rcu_init();           /* 初始化RCU,RCU全称为Read Copy Update(读-拷贝修改) */
  70.     trace_init();        /* 跟踪调试相关初始化 */

  71.     context_tracking_init();   
  72.     radix_tree_init();            /* 基数树相关数据结构初始化 */
  73.     early_irq_init();              /* 初始中断相关初始化,主要是注册irq_desc结构体变
  74.                                   * 量,因为Linux内核使用irq_desc来描述一个中断。
  75.                                   */
  76.     init_IRQ();                 /* 中断初始化 */
  77.     tick_init();                /* tick初始化 */
  78.     rcu_init_nohz();            
  79.     init_timers();              /* 初始化定时器 */
  80.     hrtimers_init();            /* 初始化高精度定时器 */
  81.     softirq_init();             /* 软中断初始化 */
  82.     timekeeping_init();         
  83.     time_init();                        /* 初始化系统时间 */
  84. sched_clock_postinit();
  85. printk_safe_init();   
  86.     perf_event_init();
  87.     profile_init();
  88.     call_function_init();
  89.     WARN(!irqs_disabled(), "Interrupts were enabled early\n");
  90.     early_boot_irqs_disabled = false;
  91.     local_irq_enable();             /* 使能中断 */

  92.     kmem_cache_init_late();        /* slab初始化,slab是Linux内存分配器  */
  93.     console_init();                 /* 初始化控制台,之前printk打印的信息都存放
  94.                                    * 缓冲区中,并没有打印出来。只有调用此函数
  95.                                    * 初始化控制台以后才能在控制台上打印信息。
  96.                                    */
  97.     if (panic_later)            
  98.         panic("Too many boot %s vars at `%s'", panic_later,
  99.               panic_param);

  100.     lockdep_info();/* 如果定义了宏CONFIG_LOCKDEP,那么此函数打印一些信息。*/

  101.     locking_selftest()                /* 锁自测 */     
  102.     ......
  103.     page_ext_init();        
  104.     kmemleak_init();                      /* kmemleak初始化,kmemleak用于检查内存泄漏 */
  105. debug_objects_mem_init();
  106. setup_per_cpu_pageset();   
  107.     numa_policy_init();
  108.     if (late_time_init)
  109.         late_time_init();      
  110.     calibrate_delay(); /* 测定BogoMIPS值,可以通过BogoMIPS来判断CPU的性能
  111.                             * BogoMIPS设置越大,说明CPU性能越好。
  112.                             */
  113.     pidmap_init();             /* PID位图初始化 */
  114.     anon_vma_init();            /* 生成anon_vma slab缓存 */         
  115.     acpi_early_init();
  116.     ......
  117.     thread_stack_cache_init();   
  118.     cred_init();                 /* 为对象的每个用于赋予资格(凭证)         */
  119.     fork_init();                 /* 初始化一些结构体以使用fork函数         */
  120.     proc_caches_init();         /* 给各种资源管理结构分配缓存                 */
  121.     buffer_init();               /* 初始化缓冲缓存                                         */
  122.     key_init();                   /* 初始化密钥                                                 */
  123.     security_init();             /* 安全相关初始化                                         */
  124.     dbg_late_init();
  125.     vfs_caches_init(totalram_pages);        /* 为VFS创建缓存         */
  126.     signals_init();                                     /* 初始化信号                 */

  127.     proc_root_init();                                   /* 注册并挂载proc文件系统 */
  128.     nsfs_init();               
  129.     cpuset_init();               /* 初始化cpuset,cpuset是将CPU和内存资源以逻辑性
  130.                                * 和层次性集成的一种机制,是cgroup使用的子系统之一
  131.                                */
  132.     cgroup_init();                              /* 初始化cgroup */
  133.     taskstats_init_early();             /* 进程状态初始化 */
  134.     delayacct_init();

  135.     check_bugs();                       /* 检查写缓冲一致性 */

  136.     acpi_subsystem_init();      
  137.     sfi_init_late();

  138.     if (efi_enabled(EFI_RUNTIME_SERVICES)) {
  139.         efi_free_boot_services();
  140.     }

  141.     rest_init();                        /* rest_init函数 */
  142. }
复制代码
       start_kernel里面调用了大量的函数,每一个函数都是一个庞大的知识点,如果想要学习Linux内核,那么这些函数就需要去详细的研究。本教程注重于嵌入式Linux入门,因此不会去讲太多关于Linux内核的知识。start_kernel函数最后调用了rest_init,接下来简单看一下rest_init函数。
1.2.4rest_init函数
       rest_init函数定义在文件init/main.c中,函数内容如下:
  1. 示例代码 17.2.5 rest_init函数
  2. 390 static noinline void __ref rest_init(void)
  3. 391 {
  4. 392     struct task_struct *tsk;
  5. 393     int pid;
  6. 394
  7. 395     rcu_scheduler_starting();
  8. 396     /*
  9. 397      * We need to spawn init first so that it obtains pid 1, however
  10. 398      * the init task will end up wanting to create kthreads, which, if
  11. 399      * we schedule it before we create kthreadd, will OOPS.
  12. 400      */
  13. 401     pid = kernel_thread(kernel_init, NULL, CLONE_FS);
  14. 402     /*
  15. 403      * Pin init on the boot CPU. Task migration is not properly working
  16. 404      * until sched_init_smp() has been run. It will set the allowed
  17. 405      * CPUs for init to the non isolated CPUs.
  18. 406      */
  19. 407     rcu_read_lock();
  20. 408     tsk = find_task_by_pid_ns(pid, &init_pid_ns);
  21. 409     set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id()));
  22. 410     rcu_read_unlock();
  23. 411
  24. 412     numa_default_policy();
  25. 413     pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
  26. 414     rcu_read_lock();
  27. 415     kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
  28. 416     rcu_read_unlock();
  29. 417
  30. 418     /*
  31. 419      * Enable might_sleep() and smp_processor_id() checks.
  32. 420      * They cannot be enabled earlier because with CONFIG_PRREMPT=y
  33. 421      * kernel_thread() would trigger might_sleep() splats. With
  34. 422      * CONFIG_PREEMPT_VOLUNTARY=y the init task might have scheduled
  35. 423      * already, but it's stuck on the kthreadd_done completion.
  36. 424      */
  37. 425     system_state = SYSTEM_SCHEDULING;
  38. 426
  39. 427     complete(&kthreadd_done);
  40. 428
  41. 429     /*
  42. 430      * The boot idle thread must execute schedule()
  43. 431      * at least once to get things moving:
  44. 432      */
  45. 433     schedule_preempt_disabled();
  46. 434     /* Call into cpu_idle with preempt disabled */
  47. 435     cpu_startup_entry(CPUHP_ONLINE);
  48. 436 }
复制代码
       第395行,调用函数rcu_scheduler_starting,启动RCU锁调度器
       第401行,调用函数kernel_thread创建kernel_init线程,也就是大名鼎鼎的init内核进程。init进程的PID为1。init进程一开始是内核进程(也就是运行在内核态),后面init进程会在根文件系统中查找名为“init”这个程序,这个“init”程序处于用户态,通过运行这个“init”程序,init进程就会实现从内核态到用户态的转变。
       第413行,调用函数kernel_thread创建kthreadd内核进程,此内核进程的PID为2。kthread进程负责所有内核进程的调度和管理。
       第435行,最后调用函数cpu_startup_entry来进入idle进程,cpu_startup_entry会调用cpu_idle_loop,cpu_idle_loop是个while循环,也就是idle进程代码。idle进程的PID为0,idle进程叫做空闲进程,如果学过FreeRTOS或者UCOS的话应该听说过空闲任务。idle空闲进程就和空闲任务一样,当CPU没有事情做的时候就在idle空闲进程里面“瞎逛游”,反正就是给CPU找点事做。当其他进程要工作的时候就会抢占idle进程,从而夺取CPU使用权。其实可以看到idle进程并没有使用kernel_thread或者fork函数来创建,因为它是由主进程演变而来的。
       在Linux终端中输入“ps -A”就可以打印出当前系统中的所有进程,其中就能看到init进程和kthreadd进程,如下图所示:
第十七章 Linux内核启动流程15197.png

图 17.2.1 Linux系统当前进程

       从上图可以看出,init进程的PID为1,kthreadd进程的PID为2。之所以上图中没有显示PID为0的idle进程,那是因为idle进程是内核进程。我们接下来重点看一下init进程,kernel_init就是init进程的进程函数。
1.2.5init进程
       kernel_init函数就是init进程具体做的工作,定义在文件init/main.c中,函数内容如下:
  1. 示例代码 17.2.6 kernel_init函数
  2. 989  static int __ref kernel_init(void *unused)
  3. 990  {
  4. 991     int ret;
  5. 992  
  6. 993     kernel_init_freeable();
  7. 994    /* need to finish all async __init code before freeing the memory */
  8. 995     async_synchronize_full();
  9. 996     ftrace_free_init_mem();
  10. 997     free_initmem();
  11. 998     mark_readonly();
  12. 999     system_state = SYSTEM_RUNNING;
  13. 1000    numa_default_policy();
  14. 1001
  15. 1002    rcu_end_inkernel_boot();
  16. 1003
  17. 1004    if (ramdisk_execute_command) {
  18. 1005        ret = run_init_process(ramdisk_execute_command);
  19. 1006        if (!ret)
  20. 1007            return 0;
  21. 1008        pr_err("Failed to execute %s (error %d)\n",
  22. 1009               ramdisk_execute_command, ret);
  23. 1010    }
  24. 1011
  25. 1012    /*
  26. 1013     * We try each of these until one succeeds.
  27. 1014     *
  28. 1015     * The Bourne shell can be used instead of init if we are
  29. 1016     * trying to recover a really broken machine.
  30. 1017     */
  31. 1018    if (execute_command) {
  32. 1019        ret = run_init_process(execute_command);
  33. 1020        if (!ret)
  34. 1021            return 0;
  35. 1022        panic("Requested init %s failed (error %d).",
  36. 1023              execute_command, ret);
  37. 1024    }
  38. 1025    if (!try_to_run_init_process("/sbin/init") ||
  39. 1026        !try_to_run_init_process("/etc/init") ||
  40. 1027        !try_to_run_init_process("/bin/init") ||
  41. 1028        !try_to_run_init_process("/bin/sh"))
  42. 1029        return 0;
  43. 1030
  44. 1031    panic("No working init found.  Try passing init= option to kernel. "
  45. 1032          "See Linux Documentation/admin-guide/init.rst for guidance.");
  46. 1033 }
复制代码
       第993行,kernel_init_freeable函数用于完成init进程的一些其他初始化工作,稍后再来具体看一下此函数。
       第1004行,ramdisk_execute_command是一个全局的char指针变量,此变量值为“/init”,也就是根目录下的init程序。ramdisk_execute_command也可以通过uboot传递,在bootargs中使用“rdinit=xxx”即可,xxx为具体的init程序名字。
       第1005行,如果存在“/init”程序的话就通过函数run_init_process来运行此程序。
       第1018行,如果ramdisk_execute_command为空的话就看execute_command是否为空,反正不管如何一定要在根文件系统中找到一个可运行的init程序。execute_command的值是通过uboot传递,在bootargs中使用“init=xxxx”就可以了,比如“init=/linuxrc”表示根文件系统中的linuxrc就是要执行的用户空间init程序。
       第1025~1028行,如果ramdisk_execute_command和execute_command都为空,那么就依次查找“/sbin/init”、“/etc/init”、“/bin/init”和“/bin/sh”,这四个相当于备用init 程序,如果这四个也不存在,那么Linux启动失败。
       第1031行,如果以上步骤都没有找到用户空间的init程序,那么就提示错误发生。
       最后来简单看一下kernel_init_freeable函数,前面说了,kernel_init会调用此函数来做一些init进程初始化工作。kernel_init_freeable定义在文件init/main.c中,缩减后的函数内容如下:
  1. 示例代码 17.2.7 kernel_init_freeable函数
  2. 1035 static noinline void __init kernel_init_freeable(void)
  3. 1036 {
  4. 1037    /*
  5. 1038     * Wait until kthreadd is all set-up.
  6. 1039     */
  7. 1040    wait_for_completion(&kthreadd_done);
  8. ……
  9. 1060
  10. 1061    smp_init();                        /* SMP 初始化 */
  11. 1062    sched_init_smp();        /* 多核(SMP)调度初始化 */
  12. 1063
  13. 1064    page_alloc_init_late();
  14. 1065
  15. 1066    do_basic_setup();        /* 设备初始化都在此函数中完成 */
  16. 1067
  17. 1068    /* Open the /dev/console on the rootfs, this should never fail */
  18. 1069    if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
  19. 1070        pr_err("Warning: unable to open an initial console.\n");
  20. 1071
  21. 1072    (void) sys_dup(0);
  22. 1073    (void) sys_dup(0);
  23. 1074    /*
  24. 1075     * check if there is an early userspace init.  If yes, let it do all
  25. 1076     * the work
  26. 1077     */
  27. 1078
  28. 1079    if (!ramdisk_execute_command)
  29. 1080        ramdisk_execute_command = "/init";
  30. 1081
  31. 1082    if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
  32. 1083        ramdisk_execute_command = NULL;
  33. 1084        prepare_namespace();
  34. 1085    }
  35. 1086
  36. 1087    /*
  37. 1088     * Ok, we have completed the initial bootup, and
  38. 1089     * we're essentially up and running. Get rid of the
  39. 1090     * initmem segments and start the user-mode stuff..
  40. 1091     *
  41. 1092     * rootfs is available now, try loading the public keys
  42. 1093     * and default modules
  43. 1094     */
  44. 1095
  45. 1096    integrity_load_keys();
  46. 1097    load_default_modules();
  47. 1098 }
复制代码
       第1066行,do_basic_setup函数用于完成Linux下设备驱动初始化工作。do_basic_setup会调用driver_init函数完成Linux下驱动模型子系统的初始化。
       第1069行,打开设备“/dev/console”,在Linux中一切皆为文件。因此“/dev/console”也是一个文件,此文件为控制台设备。每个文件都有一个文件描述符,此处打开的“/dev/console”文件描述符为0,作为标准输入(0)。
       第1072和1073行,sys_dup函数将标准输入(0)的文件描述符复制了2次,一个作为标准输出(1),一个作为标准错误(2)。这样标准输入、输出、错误都是/dev/console了。console通过uboot的bootargs环境变量设置,“console=ttyPS0,115200”表示将/dev/ ttyPS0设置为console,也就是ZYNQ的串口0。当然,也可以设置其他的设备为console,比如虚拟控制台tty1,设置tty1为console就可以在LCD屏幕上看到系统的提示信息。
       第1084行,调用函数prepare_namespace来挂载根文件系统。跟文件系统也是由命令行参数指定的,也就是uboot的bootargs环境变量。比如“root=/dev/mmcblk1p2 rootwait rw”就表示根文件系统在/dev/mmcblk1p2中,也就是EMMC的分区2中。
       Linux内核启动流程就分析到这里,Linux内核最终是需要和根文件系统打交道的,需要挂载根文件系统,并且执行根文件系统中的init程序,以此来进入用户态。这里就正式引出了根文件系统,根文件系统也是我们系统移植的最后一片拼图。Linux移植三巨头:uboot、Linux kernel、rootfs(根文件系统)。关于根文件系统后面章节会详细的讲解,这里我们只需要知道Linux内核移植完成以后还需要构建根文件系统即可。

阿莫论坛20周年了!感谢大家的支持与爱护!!

一只鸟敢站在脆弱的枝条上歇脚,它依仗的不是枝条不会断,而是自己有翅膀,会飞。
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片,浪费大家下载带宽和论坛服务器空间,请压缩后(图片小于1兆)才上传。压缩方法可以在微信里面发给自己(不要勾选“原图),然后下载,就能得到压缩后的图片】。另外,手机版只能上传图片,要上传附件需要切换到电脑版(不需要使用电脑,手机上切换到电脑版就行,页面底部)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有:东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案:44190002001997 ) )

GMT+8, 2024-3-29 10:37

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表