AndroidL系统启动及加载流程分析
Android系统完整的启动过程
Android系统完整的启动过程，从系统层次角度可分为Linux系统层、Android系统服务层、Zygote进程模型三个阶段；从开机到启动Home Launcher完成具体的任务细节可分为七个步骤，下面就从具体的细节来解读Android系统完整的初始化过程。
一、启动BootLoaderAndroid 系统是基于Linux操作系统的，所以它最初的启动过程和Linux一样。
当设备通电后首先执行BootLoader引导装载器，BootLoader是在操作系统内核运行之前运行的一段小程序。
通过这段小程序初始化硬件设备、建立内存空间映射图，从而将系统的软硬件环境引导进入合适的状态，以便为最终调用操作系统内核准备好正确的运行环境。
而Linux系统启动时：1）首先要加载BIOS的硬件信息，并获取第一个启动设备的代号2）读取第一个启动设备的MBR的引导加载程序（lilo、grub等）的启动信息。
3）加载核心操作系统的核心信息，核心开始解压缩，并且尝试驱动所有的硬件设备。
…………在嵌入式系统中，通常不会有像BIOS那样的固件程序，因此整个系统的加载任务都是通过BootLoader完成的。
二、加载系统内核Linux内核映像通常包括两部分代码，分别为实模式代码和保护模式代码。
当BootLoader装载内核映像到代码段内存时，分别放置实模式代码和保护模式代码到不同的位置，然后进入实模式代码执行，实模式代码执行完成后转入保护模式代码。
实模式和保护模式的概念再次不做过多解释，读者可以自行查阅资料。
三、启动Init进程当系统内核加载完成之后，会首先启动Init守护进程，它是内核启动的第一个用户级进程，它的进程号总是1。
Init进程启动完成之后，还负责启动其他的一些重要守护进程，包括：Usbd进程（USB Daemon）：USB连接后台进程，负责管理USB连接。
adbd 进程（Android Debug Bridge Daemon）：ADB连接后台进程，负责管理ADB连接。
Androidinit启动过程分析-gpephone
Androidinit启动过程分析-gpephoneAndroid init 启动过程分析分析android的启动过程，从内核之上，我们首先应该从文件系统的init开始，因为init 是内核进入文件系统后第一个运行的程序，通常我们可以在linux的命令行中指定内核第一个调用谁，如果没指定那么内核将会到/sbin/, /bin/ 等目录下查找默认的init，如果没有找到那么就报告出错。
下面是曾经用过的几种开发板的命令行参数：S3C2410 启动参数：noinitrdroot=/dev/nfs nfsroot=192.168.2.56:/nfsroot/rootfs ip=192.16 8.2.188:192.168.2.56:192.168.2.56:255.255.255.0::eth0:on console=ttySAC0S3C2440 启动参数：setenv bootargs console=ttySAC0 root=/dev/nfs nfsroot=192.168.2.56:/nfsroot/rootfsip=192.168.2.175:192.168.2.56:192.168.2.201:255.255.255.0::eth0 :on mem=64M init=/initmarvell 310 启动参数：boot root=/dev/nfs nfsroot=192.168.2.56:/nfsroot/rootfs,rsize=1024,wsize=1024ip=192.168.2.176:192.168.2.201:192.168.2.201:255.255.255.0::eth 0:-On console=ttyS2,115200 mem=64M init=/initinit的源代码在文件：./system/core /init/init.c 中，init会一步步完成下面的任务：1.初始化log系统2.解析/init.rc和 /init.%hardware%.rc文件3. 执行 early-init action in the two files parsed in step 2.4. 设备初始化，例如：在/dev 下面创建所有设备节点，下载firmwares.5. 初始化属性服务器，Actually the property system is working as a share memory. Logically it looks like a registry under Windows system.6. 执行 init action in the two files parsed in step 2.7. 开启属性服务。
android启动流程
android启动流程Android启动流程：Android是一款广泛使用的移动操作系统，其启动流程是一个相对复杂的过程，涉及到多个模块的加载和启动。
下面将详细介绍Android的启动流程。
1、开机自检（Boot）当手机开机时，首先进行开机自检。
在这个阶段，系统会检测硬件设备的状态，包括电池是否齐全、屏幕是否正常等。
如果硬件设备通过了自检，系统将会开始启动。
2、引导加载程序（Bootloader）开机自检完成后，系统会加载引导加载程序（Bootloader）。
引导加载程序是硬件平台的一部分，其主要作用是启动操作系统。
在加载引导加载程序的过程中，系统会自动检测手机的存储器设备，确定存储设备中是否有可用的引导文件。
3、Linux内核加载一旦引导加载程序找到可用的引导文件，系统将会加载Linux内核。
Linux内核是Android系统的核心组件，负责管理内存、文件系统、驱动程序等。
4、文件系统加载一旦Linux内核加载完成，系统将会加载文件系统。
Android系统使用的是基于Linux的文件系统，在这个过程中，系统会加载并初始化各个文件系统，包括根文件系统、系统文件系统、数据文件系统等。
5、初始化进程（Init）一旦文件系统加载完成，系统将会启动初始化进程（Init）。
初始化进程是Android系统的第一个进程，其作用是启动系统的各个进程和服务。
6、启动用户空间（System Server）在初始化进程启动后，系统会启动用户空间，加载系统的用户界面等组件。
7、启动应用程序一旦用户空间加载完成，系统将会启动应用程序。
应用程序是Android系统的核心功能，包括系统应用程序和用户安装的应用程序。
系统应用程序包括电话、短信、浏览器等，而用户安装的应用程序则是用户根据自己的需求下载和安装的。
8、应用程序启动完成一旦应用程序启动完成，系统将进入正常运行状态，用户可以通过界面操作手机。
总结：Android系统的启动流程是一个复杂而严密的过程，经过开机自检、引导加载程序、Linux内核加载、文件系统加载、初始化进程、启动用户空间、启动应用程序等多个步骤，最终实现用户界面的显示和应用程序的运行。
基于MT6752的 android 系统启动流程分析报告
基于MT6752的Android系统启动流程分析报告1、Bootloader引导 (2)2、Linux内核启动 (23)3、Android系统启动 (23)报告人：日期：2016.09.03对于Android整个启动过程来说，基本可以划分成三个阶段：Bootloader引导、Linux kernel启动、Android启动。
但根据芯片架构和平台的不同，在启动的Bootloader阶段会有所差异。
本文以MTK的MT6752平台为例，分析一下基于该平台的Android系统启动流程。
1、Bootloader引导1.1、Bootloader基本介绍BootLoader是在操作系统运行之前运行的一段程序，它可以将系统的软硬件环境带到一个合适状态，为运行操作系统做好准备，目的就是引导linux操作系统及Android框架(framework)。
它的主要功能包括设置处理器和内存的频率、调试信息端口、可引导的存储设备等等。
在可执行环境创建好之后，接下来把software装载到内存并执行。
除了装载software，一个外部工具也能和bootloader握手(handshake)，可指示设备进入不同的操作模式，比如USB下载模式和META模式。
就算没有外部工具的握手，通过外部任何组合或是客户自定义按键，bootloader也能够进入这些模式。
由于不同处理器芯片厂商对arm core的封装差异比较大，所以不同的arm处理器，对于上电引导都是由特定处理器芯片厂商自己开发的程序，这个上电引导程序通常比较简单，会初始化硬件，提供下载模式等，然后才会加载通常的bootloader。
下面是几个arm平台的bootloader方案：marvell(pxa935) : bootROM + OBM + BLOBinformax(im9815) : bootROM + barbox + U-bootmediatek(mt6517) : bootROM + pre-loader + U-bootbroadcom(bcm2157) : bootROM + boot1/boot2 + U-boot而对MT6752平台，MTK对bootloader引导方案又进行了调整，它将bootloader分为以下两个部分：(1) 第1部分bootloader，是MTK内部(in-house)的pre-loader，这部分依赖平台。
Android启动流程分析
Zygote进程启动System Server
Zygote进程从App_main.cpp中main函数开始，调用runtime.start启动system server，最后就进入 runSelectLoopMode等待并处理来自上层的请求。
int main(int argc, const char* const argv[]){ ...... AppRuntime runtime; ...... int i = runtime.addVmArguments(argc, argv); if(i < argc){ runtime.mParentDir = argv[i++]; }
2. 从以下文件中加载默认属性值。 ① /default.prop ② /system/build.prop ③ /system/default.prop ④ /data/local.prop 属性将会按照如上顺序加载，后加载的属性覆盖原先的。
3. Init进程会启动一个属性服务器Property Service，客户端(Property Setter)只能通过 该属性服务器来进行系统属性的设置。 处理设置属性请求(Write property) 当Property Service通过unix domain socket收到用户请求时，init会调用 handle_property_set_fs函数进行处理。
Kernel创建Init进程
Android Kernel启动后，执行start_kernel函数来初始化Kernel正式运行之前各个功能。 Start_kernel函数最后调用了reset_init函数启动了如下三个进程： ① idle 是操作系统的空闲进程，当 cpu 空闲的时候会去运行它 ② kthreadd 是内核守护进程，其 PID 为 2 ③ kernel_init 函数作为进程被启动，但是之后它将读取根文件系统下的init 程序，这个
安卓启动流程
安卓启动流程Android启动流程是指当我们按下手机开机键之后，系统如何进行初始化和加载应用程序等相关操作，最终完成系统的正常启动并进入主界面的过程。
下面将详细介绍Android启动流程的主要步骤。
1. 加电与引导当我们按下手机的开机键时，电源管理芯片开始提供电力供应并接通整个电路。
同时，电源管理芯片会发送信号给处理器引导启动系统。
2. 启动引导加载程序处理器接收到启动信号后，会加载引导加载程序（Bootloader）。
引导加载程序主要负责初始化硬件设备、加载系统内核等操作。
引导加载程序是嵌入式系统中运行的一段代码，它的作用是为系统加载内核和其他软件。
3. 加载内核引导加载程序会根据设备启动模式（Fastboot、Recovery或正常启动）来选择加载相应的内核。
内核是操作系统的核心，它负责管理和控制系统的硬件资源，提供各种功能的驱动程序，同时也会启动各种系统服务。
4. 初始化设备驱动在内核加载完成后，系统会初始化设备驱动程序。
设备驱动程序负责与硬件设备进行通信和控制，让硬件设备可以正确地与系统交互。
5. 启动init进程在设备驱动程序加载完毕后，系统会启动init进程。
init进程是Android系统中的第一个用户级进程，它的PID（Process ID）为1。
init进程负责启动和管理其他用户级进程，它通过读取init.rc配置文件来确定要启动的进程和服务。
6. 启动系统服务init进程会根据init.rc配置文件的指令，启动各种系统服务，例如Binder服务、Activity Manager服务、Window Manager服务等。
这些系统服务是Android系统的核心组件，负责管理应用程序的生命周期、绘制界面等功能。
7. Zygote进程与应用程序加载在系统服务启动完成后，init进程会启动Zygote进程。
Zygote进程是Android系统中的特殊进程，其作用是为应用程序提供应用程序运行环境（即Dalvik或ART虚拟机环境）。
android开机过程
一、Android开机启动流程简介1、OS-level：由bootloader载入linux kernel后kernel开始初始化, 并载入built-in 的驱动程序。
Kernel完成开机后，载入init process，切换至user-space。
Init进程是第一个在user-space启动的进程。
2、Android-level：由init process读取init.rc，Native 服务启动，并启动重要的外部程序，例如：servicemanager、Zygote以及System Server等。
由 init process 根据硬件类型读取init.xxx.rc。
由init.xxx.rc加载init.xxx.sh。
由 init.xxx.sh 加载特定的硬件驱动。
如hi_tuner.ko、hi_demux.ko等。
3、Zygote-Mode：Zygote 启动完SystemServer 后，进入Zygote Mode，在Socket 等候命令。
随后，使用者将看到一个桌面环境（Home Screen）。
桌面环境由一个名为[Launcher]的应用程序负责提供。
本文档重点研究Android-level中的启动流程。
启动流程如下图所示：二、init process流程分析init进程简介init进程是第一个在user-space启动的进程。
由内核启动参数[init]传递给内核，如果该项没有设置，内核会按/etc/init,/bin/init,/sbin/init,/bin/sh的顺序进行尝试,如果都有的都没找到，内核会抛出 kernel panic：的错误。
init进程包含在跟文件系统中，跟文件系统被直接编译到了内核。
对init 进程的修改，需要重新编译烧写内核。
编译命令：#cd kernel#make uImagCONFIG_INITRAMFS_SOURCE=../out/target/product/Hi3716C/root/ -j 8#cp kernel/arch/arm/boot/uImage out/target/product/Hi3716C/kernel -afv 源代码路径：froyo\system\core\init编译的文件：builtins.cinit.cdevices.cproperty_service.cutil.cparser.clogo.c编译命令:make init生成的文件：/out/target/product/Hi3716C/root/initinit进程启动流程1.安装SIGCHLD信号。
android启动流程
android启动流程Android启动流程。
Android系统启动流程是指Android设备在开机时，系统从无到有的整个启动过程。
了解Android启动流程对于开发者和系统维护者来说都是非常重要的，因此本文将对Android启动流程进行详细介绍。
1. 加电启动。
当用户按下设备的电源按钮时，电源管理芯片开始为设备供电，同时CPU开始执行启动代码。
此时，设备进入了启动阶段。
2. Bootloader启动。
在加电启动后，设备会首先运行Bootloader，Bootloader是设备的引导程序，负责初始化硬件并加载操作系统。
Bootloader会检查设备的硬件情况，然后加载操作系统内核。
3. 内核启动。
一旦Bootloader加载了操作系统内核，内核开始初始化设备的硬件，包括CPU、内存、外设等。
内核还会挂载根文件系统，并启动init进程。
4. init进程启动。
init进程是Android系统的第一个用户空间进程，它负责启动系统的其他进程和服务。
init进程会读取init.rc文件，根据文件中的配置启动系统服务和应用程序。
5. 系统服务启动。
在init进程启动后，系统服务会被依次启动。
这些系统服务包括SurfaceFlinger、Zygote、AMS（Activity Manager Service）、PMS（Package Manager Service）等，它们负责管理系统的各个方面，如界面显示、应用程序管理、包管理等。
6. Launcher启动。
当系统服务启动完成后，Launcher会被启动，用户可以看到设备的桌面界面。
Launcher是Android系统的桌面管理器，负责显示桌面、启动应用程序等功能。
7. 应用程序启动。
最后，用户可以通过桌面上的图标启动各种应用程序，进入到自己想要使用的应用程序中。
总结。
Android启动流程经历了Bootloader启动、内核启动、init进程启动、系统服务启动、Launcher启动和应用程序启动等步骤。
Android系统架构、开发环境搭建及启动流程分析解析
Android系统开发环境搭建 ----烧写Flash
• 将bootable\bootloader\fastboot3.0\fastboot_burn目录 拷贝出来，里面包含烧录工具 FastBoot3.1.8.exe • 准备好tftp升级工具，并将编译源码中生成 的文件拷贝到tftp升级工具所指向的目录下 • 准备板子及串口线，准备进行烧录
• 安装依赖包：
– 64位机器：
$ sudo apt-get install git-core gnupg flex bison gperf buildessential \ zip curl zlib1g-dev libc6-dev lib32ncurses5-dev ia32-libs \ x11proto-core-dev libx11-dev lib32readline5-dev lib32z-dev \ libgl1-mesa-dev g++-multilib mingw32 tofrodos – 32位机器： $ sudo apt-get install git-core gnupg flex bison gperf buildessential \ zip curl zlib1g-dev libc6-dev libncurses5-dev \ x11proto-core-dev libx11-dev \ libgl1-mesa-dev tofrodos
Android系统开发环境搭建
Android系统开发环境搭建
• Android系统开发环境要求：
– 操作系统：Ubuntu（版本号>=10.04） – 硬盘空间：10GB – JDK 版本：1.6（根据android版本而定） – Python 版本：2.4~2.7
android手机启动过程与刷机简单分析
android手机启动过程与刷机简单分析这几天看了一些嵌入式linux系统和智能手机android系统的资料，琢磨了一下安卓手机的启动过程，虽然每种手机的CPU、主板和存储器有差别，但大致过程相似。
分享一下：手机按下电源开关键后：1、主板上电，CPU芯片加载自身片上的一小段引导代码bootloader（代码的作用：告诉CPU到哪里去寻找系统启动程序，比如到NAND flash接口去读用户程序）；2、CPU按扇区方式将NAND FLASH第一个block内的SPL（Second Program Loader二次引导程序即fastboot）加载到RAM，读取分区表，加载基本设备驱动，读取boot分区的linux内核系统；由于SPL对usb设备的支持，所以我们在手机开机时通过按开机键+音量键（不同手机可能按键组合不同），可以进入fastboot工程模式，在这种模式下能通过电脑、USB线对手机进行底层操作。
3、由linux内核加载sysytem分区内的安卓系统程序；第一段引导代码bootloader很小，cpu出厂前已经固化在芯片上了，也叫onchip引导代码，不可人工改写。
二次引导程序SPL是利用JTAG仿真器固化在Nand flash的最前端或后端，我们刷机时能进入fastboot工程模式就是它的功劳。
手机厂商对这段引导程序一般都会加锁，防止用户修改，如果这段代码被破坏，手机就成砖了，只能靠专用设备烧录或返厂维修。
只要手机能进fastboot工程模式，刷recovery、root和刷Rom都是以后的事情了，基本上不会破坏以上两段引导程序。
只要固化的引导程序完好，即使刷机时手机不能进入系统，只要能显示第一屏，一般来说都有挽救的希望，不要变砖。
刷recovery就是在recovery分区安装类似于电脑上ghost一键恢复的程序。
刷Rom包就更简单了，跟电脑装系统一样，就是将安卓系统文件覆盖进手机的system分区。
android开机启动流程简单分析
android开机启动流程简单分析android启动当引导程序启动Linux内核后，会加载各种驱动和数据结构，当有了驱动以后，开始启动Android系统同时会加载用户级别的第一个进程init（system\core\init\init.cpp）代码如下：int main(int argc, char** argv) {.....//创建文件夹，挂载// Get the basic filesystem setup we need put together in the initramdisk// on / and then we'll let the rc file figure out the rest.if (is_first_stage) {mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");mkdir("/dev/pts", 0755);mkdir("/dev/socket", 0755);mount("devpts", "/dev/pts", "devpts", 0, NULL);#define MAKE_STR(x) __STRING(x)mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));mount("sysfs", "/sys", "sysfs", 0, NULL);}.....//打印日志，设置log的级别klog_init();klog_set_level(KLOG_NOTICE_LEVEL);.....Parser& parser = Parser::GetInstance();parser.AddSectionParser("service",std::make_unique<ServiceParser>());parser.AddSectionParser("on", std::make_unique<ActionParser>());parser.AddSectionParser("import", std::make_unique<ImportParser>());// 加载init.rc配置文件parser.ParseConfig("/init.rc");}加载init.rc文件，会启动一个Zygote进程，此进程是Android系统的一个母进程，用来启动Android的其他服务进程，代码：从Android L开始，在/system/core/rootdir 目录中有4 个zygote 相关的启动脚本如下图：在init.rc文件中，有如下代码：import /init.environ.rcimport /b.rcimport /init.${ro.hardware}.rcimport /b.configfs.rcimport /init.${ro.zygote}.rc注意到上面的代码import /init.${ro.zygote}.rc，这里会读取ro.zygote这个属性，导入相应的init.rc文件。
Android系统启动过程从下往上的一个过程
init进程启动MediaServer(多媒体服务)、servicemanager(binder服务管
家)、bootanim(开机动画)等重要服务；
init进程还会孵化出installd(用于App安装)、ueventd、adbd、lmkd(用于
内存管理)等用户守护进程；
init进程孵化出Zygote进程，Zygote进程是Android系统的第一个Java
进程，Zygote是所有Java进程的父进程，Zygote进程本身是由init进程孵化
而来的。
4、Framework
Zygote进程，是由init进程通过解析init.rc文件后fork生成的，Zygote进
程主要包含：-加载ZygoteInit类，注册ZygoteSocket服务端套接字；-加载
虚拟机；-PreloadClasses；-PreloadResouces。
Zygote进程fork出SystemServ
一个进程，地位非常重要。
SystemServer进程：负责启动和管理整个Javaframework，包含
ActivityManager，PowerManager等服务。
MediaServer进程：负责启动和管理整个C++framework，包含
进程是所有内核进程的鼻祖。
Android基于Linux提供核心系统服务，
例如：安全、内存管理、进程管理、网络堆栈、驱动模型。LinuxKernel
也作为硬件和软件之间的抽象层，它隐藏具体硬件细节而为上层提供统一的
服务。如果你只是做应用开发，就不需要深入了解LinuxKernel层
3、Native
启动init进程(pid=1)，是Linux系统的用户进程，init进程是所有用户进
Android 启动流程分析
1.Android2.3.1 (Tiny210 Source) 启动分析Tiny210 的入口: /linuxrc，该程序并不开源，从符号表信息推测其加入触摸屏校准的功能，最终调用Android的/sbin/init。
1.1init 干的那些事儿干吗的：保姆(打扫卫生)，父亲(制造儿子)谁找她：她干爹(内核或者switch_root切换)代码阅读指数：★★★★★重点阅读函数:* main 入口* parse_new_section 处理init.rc配置文件（注意这里默认的service不指定class属性，则默认的classname为"default"，将被init.rc脚本的中的语句class_start default 逐一启动)* service_start 启动服务思考：* init.rc 规则* Android 系统中常用用户名和组ID及其应用范围1.2init.rc 规则init.rc最重要的两个keyword，以On开头的"ACTION"，以service开头的"Service"。
具体请参考Android源码system\core\init\readme.txt1.2.1ACTION以on打头的“ACTION”，定义启动顺序的流程(early-init,XXXXX这里省略后面详细说init, early-fs, fs, post-fs, early-boot, boot)。
它的触发是被动的，在init.c定义了启动顺序，如前面所述，可以理解为信号触发及回调。
1.2.2SERVICE* 以service打头的"SERVICE"，顾名思义，服务服务，为别人服务，是属于预先定义，1.2.3常用command1.3启动流程Android 启动流程跟init程序源码的ACTION定义有关，具体的Service跟/init.rc中的定义有关。
android开机启动流程说明
android开机启动流程说明第一步：启动linux1.Bootloader2.Kernel第二步android系统启动：入口为init.rc(system\core\rootdir)1./system/bin/service manager: Binder 守护进程；2.Runtime;3.Zygote :app-process/app-main;4.Start VM;5.Start server6.Start android service:Register to service Manager7.Start Launcher第三步：应用程序启动：运行package Managerl Init进程Android系统在启动时首先会启动Linux系统，引导加载Linux Kernel并启动init进程。
Init进程是一个由内核启动的用户级进程，是Android系统的第一个进程。
该进程的相关代码在platform\system\core\init\init.c。
在main 函数中，有如下代码：open_devnull_stdio();log_init();INFO("reading config file\n");init_parse_config_file("/init.rc");/* pull the kernel commandline and ramdisk properties file in */import_kernel_cmdline(0);get_hardware_name(hardware, &revision);snprintf(tmp, sizeof(tmp), "/init.%s.rc", hardware);init_parse_config_file(tmp);这里会加载解析init.rc和init.hardware.rc两个初始化脚本。
Android系统启动过程-uBoot+Kernel+Android
Android系统启动过程-uBoot+Kernel+Android摘要：本⽂是参考⼤量⽹上资源在结合⾃⼰查看源代码总结出来的，让⾃⼰同时也让⼤家加深对Android系统启动过程有⼀个更加深⼊的了解！再次强调，本⽂的⼤多数功劳应归功于那些原创者们，同时⼀些必要的参考链接我会⼀⼀附上。
注：由于本⼈采⽤Exynos4412开发板学习，所以本⽂⼤部分资料都是基于此处理器的简介：对于整个Android系统的启动总的来说分为三个阶段： BootLoader引导即uBoot.bin linux内核启动即zImage Android系统启动即ramdisk.img与system.img 以上四个⽂件都是经过⾃⼰编译后⽣成的且通过烧写测试，接下来开始说这三⼤部分的启动过程。
⽬录：⼀、BootLoader的启动 1.汇编部分 2.c部分 ⼆、Kernel的启动 1.zImage解压缩 2.kernel的汇编启动阶段 3.kernel的c启动阶段 三、Android的启动 1.init进程 2.init启动的各种服务 3.android启动图⽰第⼀部分：BootLoader的启动流程 uBoot的第⼀条指令从cpu/arm920t/start.S⽂件开始 1. 设置CPU进⼊SVC模式(系统管理模式)，cpsr[4:0]=0xd3。
1 #include <common.h>2 #include <config.h>34/*5 *************************************************************************6 *7 * Jump vector table as in table 3.1 in [1]8 *9 *************************************************************************10*/111213 .globl _start14 _start: b start_code15 ldr pc, _undefined_instruction16 ldr pc, _software_interrupt17 ldr pc, _prefetch_abort18 ldr pc, _data_abort19 ldr pc, _not_used20 ldr pc, _irq21 ldr pc, _fiq2223 _undefined_instruction: .word undefined_instruction24 _software_interrupt: .word software_interrupt25 _prefetch_abort: .word prefetch_abort26 _data_abort: .word data_abort27 _not_used: .word not_used28 _irq: .word irq29 _fiq: .word fiq3031 .balignl 16,0xdeadbeef 接着进⼊Start_code中：设置CPU进⼊SVC模式。
详解Android系统启动过程
详解Android系统启动过程⽬录计算机是如何启动的引导阶段加载内核阶段Android的启动过程init进程init.rc ⽂件service_manager 进程surface_flinger 进程media_server 进程Zygote 进程system_server 进程ActivityManagerService 启动完整的启动流程图计算机是如何启动的计算机的硬件包括：CPU，内存，硬盘，显卡，显⽰器，键盘⿏标等输⼊输出设备。
所有的软件都是存放在硬盘中，程序执⾏时，需要将程序从硬盘上读取到内存中，然后加载到CPU中来运⾏。
当按下开机键时，内存中什么都没有，因此需要借助某种⽅式，将操作系统加载到内存中，⽽完成这项任务的就是BIOS。
引导阶段BIOS：BIOS是主板芯⽚上的⼀个程序，计算机通电后，第⼀件事情就是读取BIOS。
BIOS⾸先进⾏硬件检测，检查计算机硬件能否满⾜运⾏的基本条件。
如果硬件出现问题，主板发出不同的蜂鸣声，启动停⽌。
如果没有问题，屏幕会显⽰CPU，内存，硬盘等信息。
硬件⾃检完成后，BIOS将控制权交给下⼀个阶段的启动程序。
这时候BIOS需要知道下⼀个启动程序存放在哪个设备中。
也就是BIOS需要⼀个外部存储设备的排序。
优先交给排在前⾯的设备。
这就是我们在BIOS中设置的启动排序。
当第⼀个存储设备被激活后，设备读取设备的第⼀个扇区，也就是前512字节。
如果这512个字节的最后两个字节是0x55和0xAA，表明设备是可以⽤作系统启动的。
如果不是，那么就会顺序启动下⼀个设备。
这前512个字节，就叫做“主引导记录”（缩写MBR）。
它负责磁盘操作系统对硬盘进⾏读写时分区合法型判断、分区引导信息定位。
MBR不属于任何⼀个CIA做系统，它先于操作系统⽽被调⼊内存，并发挥作⽤。
然后才将控制权交给主分区内的操作系统，并⽤主分区信息来管理硬盘。
MBR主要作⽤是告诉计算机到硬盘的哪个位置去找操作系统。
android系统开机启动流程分析
一，系统引导bootloader加电，cpu执行bootloader程序，正常启动系统，加载boot.img【其中包含内核。
还有ramdisk】二，内核kernelbootloader加载kernel，kernel自解压，初始化，载入built-in驱动程序，完成启动。
内核启动后会创建若干内核线程，在后装入并执行程序/sbin/init/,载入init process，切换至用户空间（user-space）内核zImage解压缩head.S【这是ARM-Linux运行的第一个文件，这些代码是一个比较独立的代码包裹器。
其作用就是解压Linux内核，并将PC指针跳到内核（vmlinux）的第一条指令】首先初始化自解压相关环境（内存等），调用decompress_kernel进行解压，解压后调用start_kernel启动内核【start_kernel是任何版本linux内核的通用初始化函数，它会初始化很多东西，输出linux版本信息，设置体系结构相关的环境，页表结构初始化，设置系统自陷入口，初始化系统IRQ，初始化核心调度器等等】，最后调用rest_init【rest_init会调用kernel_init启动init进程（缺省是/init）。
然后执行schedule开始任务调度。
这个init是由android的./system/core/init下的代码编译出来的，由此进入了android的代码】。
三，Init进程启动【init是kernel启动的第一个进程，init启动以后，整个android系统就起来了】init进程启动后，根据init.rc 和init. <machine_name>.rc脚本文件建立几个基本服务（servicemanager zygote），然后担当property service 的功能打开.rc文件，解析文件内容。
【system/core/init/init.c】将service信息放置到service.list中【system/core/init/init_parser.c】。
Android系统启动过程详解(DOC)
Android系统启动过程详解Android系统启动过程首先Android框架架构图：（来自网上，我觉得这张图看起来很清晰）Linux内核启动之后就到Android Init进程，进而启动Android相关的服务和应用。
启动的过程如下图所示：（图片来自网上，后面有地址）下面将从Android4.0源码中，和网络达人对此的总结中，对此过程加以学习了解和总结，以下学习过程中代码片段中均有省略不完整，请参照源码。
一Init进程的启动init进程，它是一个由内核启动的用户级进程。
内核自行启动（已经被载入内存，开始运行，并已初始化所有的设备驱动程序和数据结构等）之后，就通过启动一个用户级程序init的方式，完成引导进程。
init始终是第一个进程。
启动过程就是代码init.c中main函数执行过程：system\core\init\init. c在函数中执行了：文件夹建立，挂载，rc文件解析，属性设置，启动服务，执行动作，socket监听……下面看两个重要的过程：rc文件解析和服务启动。
1 rc文件解析.rc文件是Android使用的初始化脚本文件（System/Core/Init/readm e.txt中有描述：four broad classes of statements which are Actions, Commands, Services, and Options.）其中Command 就是系统支持的一系列命令，如：export，hostname，mkdir，mount，等等，其中一部分是linux 命令，还有一些是android 添加的，如：class_start <serviceclass>：启动服务，class_stop <serviceclass>：关闭服务，等等。
其中Options是针对Service 的选项的。
系统初始化要触发的动作和要启动的服务及其各自属性都在rc脚本文件中定义。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Android L系统启动及加载流程分析1、概述Android L的启动可以分为几个步骤：Linux内核启动、init进程启动、native系统服务及java系统服务启动、Home启动，主要过程如下图：图1整个启动流程跟4.4及之前的版本相差不多，只是有个别不同之处，本文我们主要分析Linux内核启动之后的过程。
2、启动过程分析2.1 init进程启动当系统内核加载完成之后，会启动init守护进程，它是内核启动的第一个用户级进程，是Android的一个进程，进程号为1，init进程启动后执行入口函数main()，主要操作为：图2AndroidL上将selinux的安全等级提高了，设为了enforcing模式，4.4上是permissive模式。
解析rc脚本文件，即init.rc脚本，该文件是Android初始化脚本，定义了一系列的动作和执行这些动作的时间阶段e aryl-init、init、early-boot、boot、post-fs等阶段。
init进程main 函数中会根据这些阶段进行解析执行。
AndroidL上为了流程更清晰，增加了charger（充电开机）、ffbm（工厂模式）、以及late-init阶段，实际上这些阶段是对其他阶段的组合执行，比如late-init：2.2 ServiceManager的启动servicemanager的启动就是init进程通过init.rc脚本启动的：源码在frameworks/native/cmds/servicemanager/service_manager.c中，servicemanager是服务管理器，它本身也是一个服务(handle=0)，通过binder调用，为native和Java系统服务提供注册和查询服务的，即某个服务启动后，需要将自己注册到servicemanager中，供其他服务或者应用查询使用。
AndroidL上servicemanger中在处理注册和查询动作之前添加了selinux安全检测相关的处理。
2.3 SurfaceFinger、MediaServer进程启动Android4.4以前，surfacefinger的启动根据属性system_init.startsurfaceflinger，决定是通过init.rc启动还是systemserver进程启动，之后的版本包括AndoridL都是通过init.rc启动的：启动后会向servicemanager进程注册服务中，该服务启动时主要功能是初始化整个显示系统，并且在初始化完成后，启动开机动画进程：当开机过程完成点亮屏幕之前，WindowManagerService通过binder通信通知SurfaceFinger停止开机动画，SurfaceFinger服务会调用bootFinished函数设置service.bootanim.exit属性，开机动画进程bootanim判断该属性为1后，停止播放开机动画。
MediaServer也是init启动较早的一个服务进程：对应代码在frameworks/av/media/mediaserver/main_mediaserver.cpp，该服务启动时会创建一些音频、camera相关的native服务，这些native服务也会注册到servicemanager中。
在播放开机动画时如果需要播放开机音，bootanim需要等待mediaserver初始化完成才会播放音乐。
2.4 Zygote启动Zygote是系统中最重要的服务，在开机过程中zygote进程创建之后系统才进入了java 环境，进入了Android环境，另一方面zygote是通过socket接收AMS发送的请求，fork新的应用程序、启动其他的java系统服务。
init进程通过init.${ro.zygote}.rc启动zygote：AndroidL是64位系统，可以支持两个zygote进程，比以前的版本增加了一个zygote，如果芯片是64位的话，ro.zygote属性为zygote64_32，init则通过init.zygote64_32.rc启动zygote，该rc文件中定义了以下两个zygote服务：分别通过app_process64,app_process32两个app_process进程来启动zygote、zygote_secondary，其中zygote为primary zygote，进程名为zygote64，会负责创建systemserver 进程，一般系统服务进程都是由zygote64进程fork出来，其他应用进程由另外一个zygote fork。
源码在frameworks/base/cmds/app_process/app_main.cpp。
该服务启动时的主要工作是创建AndroidRuntime、registerZygoteSocket创建socket端口、preload加载类和资源、创建Systemserver进程，下面根据处理的顺序进行逐步解析。
2.4.1 AndroidRuntime创建AndroidRuntime是android的运行环境（ART），在app_main.cpp中通过runtime.start("com.android.internal.os.ZygoteInit", args)启动AndroidRuntime。
源码在/frameworks/base/core/jni/AndroidRuntime.cppAndroidRuntime启动后会创建虚拟机：Android4.4上还是默认使用Dalvik虚拟机，在开发者选项中兼容ART模式，AndroidL 上完全采用了ART，加载libart.so。
startVm( )函数，首先会完成虚拟机很多资源的分配，然后初始化ART相关的option、调用JNI_CreateJavaVM()创建ART虚拟机。
由于Dalvik VM的效率不高，在android4.4开始，google就开发了AndroidRuntime即android运行环境。
Dalvik虚拟机下，应用每次运行都要将字节码转成机器码，ART不同，应用第一次安装的时候，通过dex2oat字节码就会转成机器码，并保存起来，理论上应用启动时会更快。
（但是之前陈翔工针对ART和Dalvik作过对比测试，从对比数据上看，ART 下应用的启动速度提高没有很明显，而且由于安装时的dex2oat过程，导致应用的安装和系统的启动速度会较慢，可能后期的版本androidL有优化。
）2.4.2 registerZygoteSocketAndroidRuntime启动完虚拟机之后，会创建的第一个虚拟机java进程就是ZygoteInit进程，这个ZygoteInit进程可以理解成真正的zygote，在zygoteInit的main函数中首先就是调用registerZygoteSocket(“zygote”)，注册一个LocalServerSocket类型的Socket通道，变量命名为sServerSocket，作为Socket的服务端。
当SystemServer进程创建后，在SystemServer 进程中则会创建一个Socket客户端LocalSocket，具体实现在Process.java中。
这样就创建了一个zygote和SystemServer进程的socket通信通道，所谓zygote是应用孵化器，就是利用该Socket 创建其他的应用进程。
当服务端LocalServerSocket端口准备好后，ZygoteInit的main()函数调用runSelectLoop ()进入非阻塞读操作循环，通过selectReadable()将文件描述符添加到select的列表中，如果有请求就调用ZygoteConnection类的runOnce()函数处理每一个Socket接收到的命令。
当要创建新应用时，客户端SystemServer进程中ActivityManagerService通过startActivity()一步步调用到的StartProcessLocked()函数进入Process.java,最终通过startViaZygote ->zygoteSendArgsAndGetPid，通过LocalSocket发给zygote进程,zygote在通过runOnce函数fork新进程。
2.4.3 preload预加载类和资源创建完socket之后，zygote进程开始调用preload()函数加载类和资源等信息。
这个过程会预装的Framework大部分类及资源。
preloadClasses()加载的类列表是在framework.jar中的一个文本文件列表，名称为preload-classes，该列表的原始定义在frameworks/base/preload-classes文本文件中，该文件是通过frameworks/base/tools/preload/WritePreloadedClassFile.java类自动生成的。
在Android源码编译的时候，会最终把preload-classes文件打包到framework.jar中。
预加载的资源是在frameworks/base/core/res/res/values/arrays.xml中被定义的，包含两类资源，一类是drawable资源，另一类是color资源，preloadResources()通过分别调用preloadDrawables()和preloadColorStateLists()加载这两类资源。
preloadSharedLibraries()函数加载链接库。
2.4.4 SystemServer进程创建Zygote进程加载完类和资源后，如果需要创建SystemServer（zygote64）则通过startSystemServer()->Zygote.forkSystemServer创建SystemServer进程，SystemServer进程几乎是所有java系统服务的守护进程。
SystemServer启动后首先加载libandroid_servers.so并调用nativeInit()进行初始化，之后就要启动Android的java系统服务Power Manager、Activity Manager、PackageManager、WindowManager等服务，在AndroidL之前的版本在这里将会创建一个ServerThread线程，由ServerThread线程启动这些Android Java 的关键服务。