Android研究-linux内核启动到android系统[zz]

2024年1月22日 74次阅读

很多人阅读代码，总喜欢从头开始，这样觉得很安全，有依靠，无论如何总是能知道“头”，有头就能找到任何需要的部分。

Android生在linux内核基础上，linux内核启动的最后一步，一定是启动的android的进程，下面看收集到的文章。

1. linux内核启动过程

引用地址：http://blog.csdn.net/ayangke/article/details/6888699

       内核版本：2.6.22  为什么要采用这样一个较低的版本进行移植了，因为韦东山大牛说了，低版本的才能学到东西，越是高版本需要移植时做的工作量越少，学的东西越少。

       内核启动分为三个阶段，第一是运行head.S文件和head-common.S，第三个阶段是允许第二是运行main.c文件

       对于ARM的处理器，内核第一个启动的文件是arc/arm/kernel下面的head.S文件。当然arc/arm/boot/compress下面 也有这个文件，这个文件和上面的文件略有不同，当要生成压缩的内核时zImage时，启动的是后者，后者与前者不同的时，它前面的代码是做自解压的，后面 的代码都相同。我们这里这分析arc/arm/kernel下面的head.S文件。当head.S所作的工作完成后它会跳到init/目录下跌的 main.c的start_kernel函数开始执行。

 

第一阶段：

 

首先截取部分head.S文件

ENTRY(stext)

       msr  cpsr_c,#PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode

                                          @ andirqs disabled

       mrc  p15,0, r9, c0, c0           @ get processor id

       bl    __lookup_processor_type             @ r5=procinfo r9=cpuid

       movs       r10,r5                         @ invalidprocessor (r5=0)?

       beq  __error_p                     @ yes, error ‘p’

       bl    __lookup_machine_type        @ r5=machinfo

       movs       r8,r5                           @ invalidmachine (r5=0)?

       beq  __error_a                     @ yes, error ‘a’

       bl    __create_page_tables

 

       /*

        *The following calls CPU specific code in a position independent

        *manner.  See arch/arm/mm/proc-*.S fordetails.  r10 = base of

        *xxx_proc_info structure selected by __lookup_machine_type

        *above.  On return, the CPU will be readyfor the MMU to be

        *turned on, and r0 will hold the CPU control register value.

        */

       ldr   r13,__switch_data        @ address to jump toafter

                                          @ mmuhas been enabled

       adr   lr,__enable_mmu          @ return (PIC)address

 

 

第一步,执行的是__lookup_processor_type，这个函数是检查处理器型号，它读取你的电路板的CPU型号与内核支持的处理器进行比较看是否能够处理。这个我们不关心它的具体实现过程，因为现在主流处理器内核都提供了支持。

       第二步，执行的是__lookup_machine_type，这个函数是来检查机器型号的，它会读取你bootloader传进来的机器ID和他能够处 理的机器ID进行比较看是否能够处理。内核的ID号定义在arc/arm/tool/mach_types文件中MACH_TYPE_xxxx宏定义。内 核究竟就如何检查是否是它支持的机器的呢？实际上每个机器都会在/arc/arm/mach-xxxx/smdk-xxxx.c文件中有个描述特定机器的 数据结构，如下

 

[html]
view plain
copy

  1. MACHINE_START(S3C2440,”SMDK2440″)  
  2.        /* Maintainer: Ben Dooks<ben@fluff.org> */  
  3.        .phys_io  =S3C2410_PA_UART,  
  4.        .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,  
  5.        .boot_params  = S3C2410_SDRAM_PA + 0x100,  
  6.    
  7.        .init_irq   =s3c24xx_init_irq,  
  8.        .map_io          =smdk2440_map_io,  
  9.        .init_machine  = smdk2440_machine_init,  
  10.        .timer             =&s3c24xx_timer,  
  11. MACHINE_END  
  12.    

MACHINE_START和 MACHINE_END实际上被展开成一个结构体

[html]
view plain
copy

  1. #defineMACHINE_START(_type,_name)                 \  
  2. staticconst struct machine_desc __mach_desc_##_type       \  
  3.  __used                                             \  
  4.  __attribute__((__section__(“.arch.info.init”)))= {    \  
  5.        .nr          =MACH_TYPE_##_type,           \  
  6.        .name             =_name,  
  7.         
  8. #defineMACHINE_END                          \  
  9. };  

 

于是上面的数据结构就被展开为

[html]
view plain
copy

  1. staticconst struct machine_desc __mach_desc_S3C2440     \  
  2.  __used                                             \  
  3.  __attribute__((__section__(“.arch.info.init”)))= {    \  
  4.        .nr          =MACH_TYPE_S3C2440,          \  
  5.        .name             =”SMDK2440”,};  
  6. .phys_io  = S3C2410_PA_UART,  
  7.        .io_pg_offst    = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,  
  8.        .boot_params  = S3C2410_SDRAM_PA + 0x100,  
  9.    
  10.        .init_irq   =s3c24xx_init_irq,  
  11.        .map_io          =smdk2440_map_io,  
  12.        .init_machine  = smdk2440_machine_init,  
  13.        .timer             =&s3c24xx_timer,  
  14.    
  15. }  

每个机器都会有一个machine_desc__mach_desc结构，内核通过检查每个machine_desc__mach_desc的nr 号和bootloader传上来的ID进行比较，如果相同，内核就认为支持该机器，而且内核在后面的工作中会调用该机器的 machine_desc__mach_desc_结构中的方法进行一些初始化工作。

       第三步，创建一级页表。

       第四步，在R13中保存__switch_data 这个函数的地址，在第四步使能mmu完成后会跳到该函数执行。

第五步，执行的是__enable_mmu，它是使能MMU，这个函数调用了__turn_mmu_on函数，让后在_turn_mmu_on在最 后将第三步赋给R13的值传给了PC指针 （mov    pc, r13），于是内核开始跳到__switch_data这个函数开始执行。

 

我们再来看arch/arm/kenel/head-common.S这个文件中的__switch_data函数

 

[html]
view plain
copy

  1. __switch_data:  
  2.        .long       __mmap_switched  
  3.        .long       __data_loc                    @ r4  
  4.        .long       __data_start                  @ r5  
  5.        .long       __bss_start                    @ r6  
  6.        .long       _end                            @ r7  
  7.        .long       processor_id                 @ r4  
  8.        .long       __machine_arch_type           @ r5  
  9.        .long       cr_alignment                 @ r6  
  10.        .long       init_thread_union+ THREAD_START_SP @ sp  
  11.    
  12. /*  
  13.  * The following fragment of code is executedwith the MMU on in MMU mode,  
  14.  * and uses absolute addresses; this is notposition independent.  
  15.  *  
  16.  *  r0  =cp#15 control register  
  17.  * r1  = machine ID  
  18.  * r9  = processor ID  
  19.  */  
  20.        .type       __mmap_switched,%function  
  21. __mmap_switched:  
  22.        adr   r3,__switch_data + 4  
  23.    
  24.        ldmia      r3!,{r4, r5, r6, r7}  
  25.        cmp r4,r5                           @ Copy datasegment if needed  
  26. 1:    cmpne     r5,r6  
  27.        ldrne       fp,[r4], #4  
  28.        strne       fp,[r5], #4  
  29.        bne  1b  
  30.    
  31.        mov fp,#0                           @ Clear BSS(and zero fp)  
  32. 1:    cmp r6,r7  
  33.        strcc fp,[r6],#4  
  34.        bcc  1b  
  35.    
  36.        ldmia      r3,{r4, r5, r6, sp}  
  37.        str    r9, [r4]                  @ Save processor ID  
  38.        str    r1, [r5]                  @ Save machine type  
  39.        bic   r4,r0, #CR_A               @ Clear ‘A’ bit  
  40.        stmia       r6,{r0, r4}                   @ Save controlregister values  
  41.        b     start_kernel  

 

这个函数做的工作是，复制数据段清楚BBS段，设置堆在指针，然后保存处理器内核和机器内核等工作，最后跳到start_kernel函数。于是内核开始执行第二阶段。

 

第二阶段：

 

       我们再来看init/目录下的main.c的start_kernel函数，这里我只截图了部分。

[html]
view plain
copy

  1. asmlinkage void __init start_kernel(void)  
  2. {  
  3.        …………………….  
  4.        ……………………..  
  5.        printk(KERN_NOTICE);  
  6.        printk(linux_banner);  
  7.        setup_arch(&command_line);  
  8.        setup_command_line(command_line);  
  9.         
  10.         
  11.        parse_early_param();  
  12.        parse_args(“Booting kernel”,static_command_line, __start___param,  
  13.                 __stop___param – __start___param,  
  14.                 &unknown_bootoption);  
  15. ……………………  
  16. …………………………        
  17.        init_IRQ();  
  18.        pidhash_init();  
  19.        init_timers();  
  20.        hrtimers_init();  
  21.        softirq_init();  
  22.        timekeeping_init();  
  23.        time_init();  
  24.        profile_init();  
  25. …………………………  
  26. ……………………………  
  27.        console_init();  
  28. ………………………………  
  29. ………………………………  
  30.        rest_init();  
  31. }  

从上面可以看出start_kernel首先是打印内核信息，然后对bootloader传进来的一些参数进行处理，再接着执行各种各样的初始化，在这其中会初始化控制台。最后会调用rest_init();

我们再来看rest_init()函数

[html]
view plain
copy

  1. static void noinline __init_refok rest_init(void)  
  2.     __releases(kernel_lock)  
  3. {  
  4.     int pid;  
  5.   
  6.     kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);  
  7.     …………      
  8. }   

 他启动了kernel_init这个函数，再来看kerne_init函数

[html]
view plain
copy

  1. static int __init kernel_init(void * unused)  
  2. {  
  3.     …………………………  
  4.   
  5.     if (!ramdisk_execute_command)  
  6.         ramdisk_execute_command = “/init”;  
  7.   
  8.     if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {  
  9.         ramdisk_execute_command = NULL;  
  10.         prepare_namespace();  
  11.     }  
  12.   
  13.     /*  
  14.      * Ok, we have completed the initial bootup, and  
  15.      * we’re essentially up and running. Get rid of the  
  16.      * initmem segments and start the user-mode stuff..  
  17.      */  
  18.     init_post();  
  19.     return 0;  
  20. }  

kernel_init先调用了prepare_namespace();然后调用了init_post函数

[html]
view plain
copy

  1. void __init prepare_namespace(void)  
  2. {  
  3.     ……………………..  
  4.     mount_root();  
  5.     …………………  
  6. }  

可以看出prepare_namespace调用了mount_root挂接根文件系统。接着kernel_init再执行init_post

[html]
view plain
copy

  1. static int noinline init_post(void)  
  2. {  
  3.     …………………………………  
  4.     /*打开dev/console控制台，并设置为标准输入、输出*/  
  5.           
  6.     if (sys_open((const char __user *) “/dev/console”, O_RDWR, 0) < 0)  
  7.         printk(KERN_WARNING “Warning: unable to open an initial console.\n”);  
  8.   
  9.     (void) sys_dup(0);  
  10.     (void) sys_dup(0);  
  11.   
  12.     if (ramdisk_execute_command) {  
  13.         run_init_process(ramdisk_execute_command);  
  14.         printk(KERN_WARNING “Failed to execute %s\n”,  
  15.                 ramdisk_execute_command);  
  16.     }  
  17.   
  18.     /*  
  19.      * We try each of these until one succeeds.  
  20.      *  
  21.      * The Bourne shell can be used instead of init if we are  
  22.      * trying to recover a really broken machine.  
  23.      */  
  24.   
  25.     //如果bootloader指定了init参数，则启动init参数指定的进程  
  26.     if (execute_command) {  
  27.         run_init_process(execute_command);  
  28.         printk(KERN_WARNING “Failed to execute %s.  Attempting ”  
  29.                     “defaults…\n”, execute_command);  
  30.     }  
  31.   
  32.     //如果没有指定init参数，则分别带sbin、etc、bin目录下启动init进程  
  33.     run_init_process(“/sbin/init”);  
  34.     run_init_process(“/etc/init”);  
  35.     run_init_process(“/bin/init”);  
  36.     run_init_process(“/bin/sh”);  
  37.   
  38.     panic(“No init found.  Try passing init= option to kernel.”);  
  39. }  

 

注意上面的run_init_process的会等待init进程返回才往后面执行，所有它一旦找到一个init可执行的文件它将一去不复返。

综上，内核启动的过程大致为以下几步：

1.检查CPU和机器类型

2.进行堆栈、MMU等其他程序运行关键的东西进行初始化

3.打印内核信息

4.执行各种模块的初始化

5.挂接根文件系统

6.启动第一个init进程

2. android启动

引用地址：http://monner.iteye.com/blog/728334

Android 系统启动分析（转）

init进程是Android启动后系统执行的第一个名称为init的可执行程序。这个程序以一个守护进程的方式运行，它提供了以下功能：

1、init可执行程序

init 可执行文件是系统运行的第一个用户空间程序，它以守护进程的方式运行。因此这个程序的init.c文件包含main函数的入口，基本分析如下： 

int main(int argc,char**argv){    (省略若干。。。)         umask(0);  /*对umask进行清零。*/         mkdir("/dev",0755);/*为rootfs建立必要的文件夹，并挂载适当的分区。 */     mkdir("/proc",0755);     mkdir("/sys",0755);     mount("tmpfs","/dev","tmpfs",0,"mode=0755");     mkdir("/dev/pts",0755);     mkdir("/dev/socket",0755);     mount("devpts","/dev/pts","devpts",0, NULL);     mount("proc","/proc","proc",0, NULL);     mount("sysfs","/sys","sysfs",0, NULL);     /*创建/dev/null和/dev/kmsg节点*/     open_devnull_stdio();     log_init();         /*解析/init.rc，将所有服务和操作信息加入链表。*/     INFO("reading config file\n");     parse_config_file("/init.rc");     /*获取内核命令行参数*/     qemu_init();     import_kernel_cmdline(0);     /*先从上一步获得的全局变量中获取信息硬件信息和版本号，如果没有则从/proc/cpuinfo中提取，      *并保存到全局变量。根据硬件信息选择一个/init.(硬件).rc，并解析，将服务和操作信息加入链表。      */     get_hardware_name();     snprintf(tmp,sizeof(tmp),"/init.%s.rc", hardware);     parse_config_file(tmp);     /*执行链表中带有“early-init”触发的的命令。*/     action_for_each_trigger("early-init", action_add_queue_tail);     drain_action_queue();     /*遍历/sys文件夹，是内核产生设备添加事件（为了自动产生设备节点)。      *初始化属性系统，并导入初始化属性文件。用于在系统运行过程中动态创建设备节点、删除设备节点等操作      */     INFO("device init\n");     device_fd = device_init();     property_init();         // 从属性系统中得到ro.debuggable，若为1，则初始化keychord监听。     debuggable = property_get("ro.debuggable");     if(debuggable &&!strcmp(debuggable,"1")){         keychord_fd = open_keychord();     }     /*打开console，如果cmdline中没有指定的console则打开默认的/dev/console*/         if(console[0]){         snprintf(tmp,sizeof(tmp),"/dev/%s", console);         console_name = strdup(tmp);     }     fd = open(console_name, O_RDWR);     if(fd >=0)         have_console =1;     close(fd);     /*读取/initlogo.rle（一张位图），如果成功则在/dev/graphics/fb0 显示Logo,如果失败则将/dev/tty0      *设为TEXT模式并打开/dev/tty0,输出文本ANDROID（本人修改为Zhao Rui Jia做为启动项目的修改）。      */     if( load_565rle_image(INIT_IMAGE_FILE)){     fd = open("/dev/tty0", O_WRONLY);     if(fd >=0){         constchar*msg;             msg ="\n"         "\n"         "\n"         "\n"         "\n"         "\n"         "\n"  // console is 40 cols x 30 lines         "\n"         "\n"         "\n"         "\n"         "\n"         "\n"         "\n"       /*"             A N D R O I D ";*/         "          z h a o R u i J i a";         write(fd, msg, strlen(msg));         close(fd);     }     }    /* 判断cmdline 中的參數，并设置属性系统中的参数:     *  1、 如果 bootmode为     *     - factory,设置ro.factorytest值为1     *     - factory2,设置ro.factorytest值为2     *     - 其他的設ro.factorytest值為0     *  2、如果有serialno参数，则设置ro.serialno，否则为""     *  3、如果有bootmod参数，则设置ro.bootmod，否则为"unknown"     *  4、如果有baseband参数，则设置ro.baseband，否则为"unknown"     *  5、如果有carrier参数，则设置ro.carrier，否则为"unknown"     *  6、如果有bootloader参数，则设置ro.bootloader，否则为"unknown"     *  7、通过全局变量（前面从/proc/cpuinfo中提取的）设置ro.hardware和ro.version。     */     if(qemu[0])         import_kernel_cmdline(1);     if(!strcmp(bootmode,"factory"))         property_set("ro.factorytest","1");     elseif(!strcmp(bootmode,"factory2"))         property_set("ro.factorytest","2");     else         property_set("ro.factorytest","0");     property_set("ro.serialno", serialno[0]? serialno :"");     property_set("ro.bootmode", bootmode[0]? bootmode :"unknown");     property_set("ro.baseband", baseband[0]? baseband :"unknown");     property_set("ro.carrier", carrier[0]? carrier :"unknown");     property_set("ro.bootloader", bootloader[0]? bootloader :"unknown");     property_set("ro.hardware", hardware);     snprintf(tmp, PROP_VALUE_MAX,"%d", revision);     property_set("ro.revision", tmp);     /*执行所有触发标识为init的action。*/         action_for_each_trigger("init", action_add_queue_tail);     drain_action_queue();     property_set_fd = start_property_service();      /* 为sigchld handler创建信号机制*/        if(socketpair(AF_UNIX, SOCK_STREAM,0, s)==0){         signal_fd = s[0];         signal_recv_fd = s[1];         fcntl(s[0], F_SETFD, FD_CLOEXEC);         fcntl(s[0], F_SETFL, O_NONBLOCK);         fcntl(s[1], F_SETFD, FD_CLOEXEC);         fcntl(s[1], F_SETFL, O_NONBLOCK);     }     /* 确认所有初始化工作完成      * device_fd(device init 完成)      * property_set_fd(property server start 完成)      * signal_recv_fd (信号机制建立)      */     if((device_fd <0)||         (property_set_fd <0)||         (signal_recv_fd <0)){         ERROR("init startup failure\n");         return1;     }     /* execute all the boot actions to get us started */     action_for_each_trigger("early-boot", action_add_queue_tail);     action_for_each_trigger("boot", action_add_queue_tail);     drain_action_queue();     /* run all property triggers based on current state of the properties */     queue_all_property_triggers();     drain_action_queue();     /* enable property triggers */       property_triggers_enabled =1;       /*    *    注册轮询事件:    *   - device_fd    *   - property_set_fd    *   -signal_recv_fd    *   -如果有keychord，则注册keychord_fd    */     ufds[0].fd = device_fd;     ufds[0].events = POLLIN;     ufds[1].fd = property_set_fd;     ufds[1].events = POLLIN;     ufds[2].fd = signal_recv_fd;     ufds[2].events = POLLIN;     fd_count =3;     if(keychord_fd >0){         ufds[3].fd = keychord_fd;         ufds[3].events = POLLIN;         fd_count++;     }else{         ufds[3].events =0;         ufds[3].revents =0;     }/*如果支持BOOTCHART,则初始化BOOTCHART*/#if BOOTCHART     bootchart_count = bootchart_init();     if(bootchart_count <0){         ERROR("bootcharting init failure\n");     }elseif(bootchart_count >0){         NOTICE("bootcharting started (period=%d ms)\n", bootchart_count*BOOTCHART_POLLING_MS);     }else{         NOTICE("bootcharting ignored\n");     }#endif   /*      *进入主进程循环:    *  - 重置轮询事件的接受状态，revents为0    *  - 查询action队列并执行。    *  - 重启需要重启的服务    *  - 轮询注册的事件    *       - 如果signal_recv_fd的revents为POLLIN，则得到一个信号，获取并处理    *       - 如果device_fd的revents为POLLIN,调用handle_device_fd    *       - 如果property_fd的revents为POLLIN,调用handle_property_set_fd    *       - 如果keychord_fd的revents为POLLIN,调用handle_keychord    */    for(;;){         int nr, i, timeout =-1;         for(i =0; i < fd_count; i++)             ufds[i].revents =0;         drain_action_queue();         restart_processes();         if(process_needs_restart){             timeout =(process_needs_restart - gettime())*1000;             if(timeout <0)                 timeout =0;         }#if BOOTCHART         if(bootchart_count >0){             if(timeout <0|| timeout > BOOTCHART_POLLING_MS)                 timeout = BOOTCHART_POLLING_MS;             if(bootchart_step()<0||--bootchart_count ==0){                 bootchart_finish();                 bootchart_count =0;             }         }#endif         nr = poll(ufds, fd_count, timeout);         if(nr <=0)             continue;         if(ufds[2].revents == POLLIN){             /* we got a SIGCHLD - reap and restart as needed */             read(signal_recv_fd, tmp,sizeof(tmp));             while(!wait_for_one_process(0))                 ;             continue;         }         if(ufds[0].revents == POLLIN)             handle_device_fd(device_fd);         if(ufds[1].revents == POLLIN)             handle_property_set_fd(property_set_fd);         if(ufds[3].revents == POLLIN)             handle_keychord(keychord_fd);     }     return0;}

2、启动脚本init.rc

在 Android中使用启动脚本init.rc,可以在系统的初始化过程中进行一些简单的初始化操作。这个脚本被直接安装到目标系统的根文件系统中，被 init可执行程序解析。 init.rc是在init启动后被执行的启动脚本，其余发主要包含了以下内容：

Commands是一些基本的操作，例如： 

    mkdir /sdcard 0000 system system     mkdir /system     mkdir /data 0771 system system     mkdir /cache 0770 system cache     mkdir /config 0500 root root     mkdir /sqlite_stmt_journals 01777 root root     mount tmpfs tmpfs /sqlite_stmt_journals size=4m

这些命令在init可执行程序中被解析，然后调用相关的函数来实现。 Actions(动作)表示一系列的命令，通常在Triggers（触发条件）中调用，动作和触发条件例如： 

    on init     export PATH /sbin:/system/sbin:/system/bin:/system/xbin

init表示一个触发条件，这个触发事件发生后，进行设置环境变量和建立目录的操作称为一个“动作” Services（服务）通常表示启动一个可执行程序，Options（选项）是服务的附加内容，用于配合服务使用。 

service vold /system/bin/vold     socket vold stream 0660 root mount service bootsound /system/bin/playmp3     user media     group audio     oneshot

vold和bootsound分别是两个服务的名称，/system/bin /vold和/system /bin/playmp3分别是他们所对应的可执行程序。socket、user、group、oneshot就是配合服务使用的选项。 Properties（属性）是系统中使用的一些值，可以进行设置和读取。 

    setprop ro.FOREGROUND_APP_MEM 1536     setprop ro.VISIBLE_APP_MEM 2048     start adbd

setprop 用于设置属性，on property可以用于判断属性，这里的属性在整个Android系统运行中都是一致的。

综上如果想要修改启动过程只需要修改init.c或者init.rc里的内容即可.


3. 总结：

(1)内核的init_post类似接口，会去文件系统中启动init类似的用户进程

(2)android实现了这样的init，这就是android框架启动的地方，当然linux内核也可说是android系统的一部分

(3)init进程无限分裂，启动框架，演变成android系统

(4)android的init进程的代码在system/core/init/init.c中，从main函数开始.

 

本文完~

点赞