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

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文件中有个描述特定机器的 数据结构，如下

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

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

每个机器都会有一个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函数

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

第二阶段：

 

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

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

我们再来看rest_init()函数

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

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

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

注意上面的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：命令
• Actions：动作
• Triggers:触发条件
• Services：服务
• Options：选项
• Propertise：属性

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函数开始.

本文完~

Android研究-linux内核启动到android系统相关推荐

1. 修改linux内核启动动画,Android 开机界面及Linux内核启动界面的修改（tiny6410）

   第一开机界面替换,即内核bootloader启动小企鹅界面更换 1.首先找一个自定义120*120的png图像,这里名称linux.png,但是后面的ppm名称必须是图中所示 在linux下执行下面代 ...

2. linux文件系统启动流程,linux 内核启动过程以及挂载android 根文件系统的过程

   转载 作者:汕头大学-黄珠唐 时间:2009 年10 月29 日 主要介绍linux 内核启动过程以及挂载android 根文件系统的过程,以及介绍android 源代码中文件系统部分的浅析. 主要源 ...

3. Linux内核启动及文件系统加载过程

   当u-boot开始执行bootcmd命令,就进入linux内核启动阶段 与 u-boot 类似,普通 Linux 内核的启动过程也可以分为两个阶段,但针对压缩了的内核如 uImage 就要包括内核自解 ...

4. linux内核如何修改lowmem,技术内幕：Android对Linux内核的增强 Low Memory Killer

   6 09 2013 技术内幕:Android对Linux内核的增强 Low Memory Killer Low Memory Killer(低内存管理) 对于PC来说,内存是 至关重要.如果某个程序发 ...

5. 如何编译android的linux 内核,ubuntu下编译android内核（arm-none-linux-gnueabi-）

   解压缩内核: $ mkdir -p android $ cd android $ tar xzvf ../linux-2.6.23-android-m3-rc20.tar.gz 会解压出来一个叫做ke ...

6. 下载android的linux内核的方法

   1.安装git android的linux内核可以从http://android.git.kernel.org/下载,但下载需要使用git,windows版的git可以从http://code.goo ...

7. Linux内核启动流程（待完善）

   文章目录 一.Linux内核自解压过程 二.Linux内核启动第二阶段stage1 2.1.linux系统启动入口函数(stext) 2.2.内核初始化阶段(start_kernel) 2.3.2 r ...

8. 解决ubuntu更改Linux内核（或更新系统）后扩展屏（第二显示器）无法正常显示问题)

   解决ubuntu更改Linux内核(或更新系统)后扩展屏(第二显示器)无法正常显示问题 我的解决方案 一定先看这个(很重要) 直接看这个就可以 前几天更新了一下ubuntu系统,一切正常,但是当我把系 ...

9. 【内核】linux内核启动流程详细分析【转】

   转自:http://www.cnblogs.com/lcw/p/3337937.html Linux内核启动流程 arch/arm/kernel/head-armv.S 该文件是内核最先执行的一个文件 ...

最新文章

1. 服务器架设笔记——搭建用户注册和验证功能
2. 硬核教程：五步掌握用VSCode进行高效Python开发
3. “复制粘贴”发明人，竟是物理学博士转行做程序媛！
4. mysql.zip要什么下载_mysql用zip安装方法是什么
5. mysql 触发器 sql日志_触发器实现记录操作表的日志
6. [C++]Linux之C编程异常[true未定义解决方案]
7. 学习web前端前景怎么样？
8. mysql五:索引原理与慢查询优化
9. 【转】我应该直接学Swift还是Objective-C？
10. 为什么说Mobileye最辉煌的5年就是落后的5年
11. 简洁大气的网站微信QQ防红跳转代码
12. 上海市计算机二级vb试题及答案,上海计算机二级VB试题
13. C++沉思录(Ruminations on C++)中文第2版电子书pdf下载
14. Scrapy0.24.1_中文文档
15. css实现气泡框效果
16. 小明左右手分别拿两张纸牌:黑桃10和红心8，现在交换手中的牌。编写并输出互换后的结果，输出结果如图所示
17. Spring 创建切面
18. QWebEngineView崩溃及替代方案
19. JDBC、封装JDBC连接池、第三方连接池工具
20. Delphi使用ADOconnection连接mysql数据库时的Connectionstring问题

热门文章

1. Battery Historian 使用常用命令
2. CSS3 ::selection选择器
3. DNS原理及其解析过程（转）
4. 注意语句顺序 防止Servlet Request Response乱码
5. (android控件)ListView的Item中设置按钮实现
6. Latent dirichlet allocation note -- Prepare
7. 三个单词说的英语口语
8. DES算法详解和代码 - IP置换
9. 理解__repr__
10. 东莞新能源——业务流程管理实践