原文地址：http://www.cnblogs.com/bastard/archive/2012/08/28/2660389.html
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/readme.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脚本文件中定义。 具体看一下启动脚本：\system\core\rootdir\init.rc
在解析rc脚本文件时，将相应的类型放入各自的List中：
\system\core\init\Init_parser.c ：init_parse_config_file( )存入到
action_queue、 action_list、 service_list中，解析过程可以看一下parse_config函数，类似状态机形式挺有意思。
这其中包含了服务：adbd、servicemanager、vold、ril-daemon、debuggerd、surfaceflinger、zygote、media……
2 服务启动
文件解析完成之后将service放入到service_list中。
文件解析完成之后将service放入到service_list中。
\system\core\init\builtins.c
Service的启动是在do_class_start函数中完成：
int do_class_start(int nargs, char **args)
{
service_for_each_class(args[1], service_start_if_not_disabled);
return 0;
}
遍历所有名称为classname，状态不为SVC_DISABLED的Service启动
void service_for_each_class(const char *classname,
void (*func)(struct service *svc))
{
……
}
static void service_start_if_not_disabled(struct service *svc)
{
if (!(svc->flags & SVC_DISABLED)) {
service_start(svc, NULL);
}
}
do_class_start对应的命令：
KEYWORD(class_start, COMMAND, 1, do_class_start)
init.rc文件中搜索class_start：class_start main 、class_start core、……
main、core即为do_class_start参数classname
init.rc文件中Service class名称都是main：
service drm /system/bin/drmserver
class main
service surfaceflinger /system/bin/surfaceflinger
class main
于是就能够通过main名称遍历到所有的Service，将其启动。
do_class_start调用：
init.rc中
on boot //action
class_start core //执行command 对应 do_class_start
class_start main
Init进程main函数中：
system/core/init/init.c中：
int main(){
//挂在文件
//解析配置文件：init.rc……
//初始化化action queue
……
for(;;){
execute_one_command();
restart_processes();
for (i = 0; i < fd_count; i++) {
if (ufds[i].revents == POLLIN) {
if (ufds[i].fd == get_property_set_fd())
handle_property_set_fd();
else if (ufds[i].fd == get_keychord_fd())
handle_keychord();
else if (ufds[i].fd == get_signal_fd())
handle_signal();
}
}
}
}
循环调用service_start，将状态SVC_RESTARTING启动， 将启动后的service状态设置为SVC_RUNNING。
pid=fork();
execve();
在消息循环中：Init进程执行了Android的Command，启动了Android的NativeService，监听Service的变化需求，Signal处理。
Init进程是作为属性服务（Property service），维护这些NativeService。
二 ServiceManager启动
在.rc脚本文件中zygote的描述：
service servicemanager /system/bin/servicemanager
class core
user system
group system
critical
onrestart restart zygote
onrestart restart media
onrestart restart surfaceflinger
onrestart restart drm
ServiceManager用来管理系统中所有的binder service，不管是本地的c++实现的还是java语言实现的都需要
这个进程来统一管理，最主要的管理就是，注册添加服务，获取服务。所有的Service使用前都必须先在servicemanager中进行注册。
do_find_service( )
do_add_service( )
svcmgr_handler( )
代码位置：frameworks\base\cmds\servicemanager\Service_manager.c
三 Zygote进程的启动
Zygote这个进程是非常重要的一个进程，Zygote进程的建立是真正的Android运行空间，初始化建立的Service都是Navtive service.
（1） 在.rc脚本文件中zygote的描述：
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
参数：--zygote --start-system-server
代码位置：frameworks/base/cmds/app_process/app_main.cpp
上面的参数在这里就会用上，决定是否要启动和启动那些进程。
int main( ){
AppRuntime runtime;
if (zygote) {
runtime.start("com.android.internal.os.ZygoteInit",
startSystemServer ? "start-system-server" : "");
}
}
class AppRuntime : public AndroidRuntime{}；
（2） 接着到了AndroidRuntime类中：
frameworks\base\core\jni\AndroidRuntime.cpp
void start(const char* className, const char* options){
// start the virtual machine Java在虚拟机中运行的
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {
return;
}
//向刚刚新建的虚拟机注册JNI本地接口
if (startReg(env) < 0) {
return;
}
// jni 调用 java 方法，获取对应类的静态main方法
jmethodID startMeth = env->GetStaticMethodID(startClass,
"main","([Ljava/lang/String;)V");
// jni调用 java方法，调用到ZygoteInit类的main函数
jclass startClass = env->FindClass(className);
env->CallStaticVoidMethod(startClass, startMeth, strArray);
}
到了ZygoteInit.java中的静态main函数中，从C++ ——》JAVA
（3）ZygoteInit
真正Zygote进程:
frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
public static void main(String argv[]) {
//Registers a server socket for zygote command connections
registerZygoteSocket();
//Loads and initializes commonly used classes and
//used resources that can be shared across processes
preload();
// Do an initial gc to clean up after startup
gc();
if (argv[1].equals("start-system-server")) {
startSystemServer();
}
/**
* Runs the zygote process's select loop. Accepts new connections as
* they happen, and reads commands from connections one spawn-request's
* worth at a time.
*/
runSelectLoopMode(); //loop中
/**
* Close and clean up zygote sockets. Called on shutdown and on the
* child's exit path.
*/
closeServerSocket();
}
Zygote就建立好了，利用Socket通讯，接收请求，Fork应用程序进程，进入Zygote进程服务框架中。
四 SystemServer启动
（1）在Zygote进程进入循环之前，调用了startSystemServer( );
private static boolean startSystemServer(){
/* Request to fork the system server process 孵化新的进程 */
ZygoteConnection.Arguments parsedArgs = null;
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
/* For child process 对新的子进程设置 */
if (pid == 0) {
handleSystemServerProcess(parsedArgs);
}
}
void handleSystemServerProcess(parsedArgs){
closeServerSocket();
//"system_server"
Process.setArgV0(parsedArgs.niceName);
//Pass the remaining arguments to SystemServer.
RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
parsedArgs.remainingArgs);
/* should never reach here */
}
（2）RuntimeInit中：
frameworks\base\core\java\com\android\internal\os\RuntimeInit.java
//The main function called when started through the zygote process.
void zygoteInit(int targetSdkVersion, String[] argv){
applicationInit(targetSdkVersion, argv);
}
void applicationInit(int targetSdkVersion, String[] argv){
// Remaining arguments are passed to the start class's static main
invokeStaticMain(args.startClass, args.startArgs);
}
void invokeStaticMain(String className, String[] argv){
Class<?> cl;
cl = Class.forName(className);
//获取SystemServer的main方法，抛出MethodAndArgsCaller异常
Method m;
m = cl.getMethod("main", new Class[] { String[].class });
int modifiers = m.getModifiers();
throw new ZygoteInit.MethodAndArgsCaller(m, argv);
}
（3）从startSystemServer开始执行并没有去调用SystemServer的任何方法，
只是通过反射获取了main方法，付给了MethodAndArgsCaller，并抛出了MethodAndArgsCaller异常。
此异常是在哪里处理的呢？
回到startSystemServer( )函数的调用处：
在ZygoteInit的main函数中：
public static void main(String argv[]) {
try {
……
if (argv[1].equals("start-system-server")) {
startSystemServer(); //这里如果抛出异常，跳过下面流程
}
runSelectLoopMode(); //loop中
……
} catch (MethodAndArgsCaller caller) {
caller.run(); //处理的异常
}
}
如果startSystemServer抛出了异常，跳过执行ZygoteInit进程的循环，这是怎么回事呢？
在startSystemServer中异常是由handleSystemServerProcess抛出，而
pid = Zygote.forkSystemServer( )
/* For child process 仅对新的子进程设置 */
if (pid == 0) {