Android系统进程Zygote启动过程的源代码分析

在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的，这也许就是为什么要把它称为Zygote（受精卵）的原因吧。由于Zygote进程在Android系统中有着如此重要的地位，本文将详细分析它的启动过程。

在前面一篇文章Android应用程序进程启动过程的源代码分析中，我们看到了，当ActivityManagerService启动一个应用程序的时候，就会通过Socket与Zygote进程进行通信，请求它fork一个子进程出来作为这个即将要启动的应用程序的进程；在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序（Launcher）的启动过程源代码分析中，我们又看到了，系统中的两个重要服务PackageManagerService和ActivityManagerService，都是由SystemServer进程来负责启动的，而SystemServer进程本身是Zygote进程在启动的过程中fork出来的。

我们知道，Android系统是基于Linux内核的，而在Linux系统中，所有的进程都是init进程的子孙进程，也就是说，所有的进程都是直接或者间接地由init进程fork出来的。Zygote进程也不例外，它是在系统启动的过程，由init进程创建的。在系统启动脚本system/core/rootdir/init.rc文件中，我们可以看到启动Zygote进程的脚本命令：

servicezygote/system/bin/app_process-Xzygote/system/bin--zygote--start-system-server
socketzygotestream666
onrestartwrite/sys/android_power/request_statewake
onrestartwrite/sys/power/stateon
onrestartrestartmedia
onrestartrestartnetd

前面的关键字service告诉init进程创建一个名为"zygote"的进程，这个zygote进程要执行的程序是/system/bin/app_process，后面是要传给app_process的参数。

接下来的socket关键字表示这个zygote进程需要一个名称为"zygote"的socket资源，这样，系统启动后，我们就可以在/dev/socket目录下看到有一个名为zygote的文件。这里定义的socket的类型为unix domain socket，它是用来作本地进程间通信用的，具体可以参考前面一篇文章Android学习启动篇提到的一书《Linux内核源代码情景分析》的第七章--基于socket的进程间通信。前面我们说到的ActivityManagerService就是通这个socket来和zygote进程通信请求fork一个应用程序进程的了。

最后的一系列onrestart关键字表示这个zygote进程重启时需要执行的命令。

关于init.rc文件的更多信息，请参考system/core/init/readme.txt文件。

了解了这个信息之后，我们就知道Zygote进程要执行的程序便是system/bin/app_process了，它的源代码位于frameworks/base/cmds/app_process/app_main.cpp文件中，入口函数是main。在继续分析Zygote进程启动的过程之前，我们先来看看它的启动序列图：

下面我们就详细分析每一个步骤。

Step 1. app_process.main

这个函数定义在frameworks/base/cmds/app_process/app_main.cpp文件中：

intmain(intargc,constchar*constargv[])
{
//TheseareglobalvariablesinProcessState.cpp
mArgC=argc;
mArgV=argv;

mArgLen=0;
for(inti=0;i<argc;i++){
mArgLen+=strlen(argv[i])+1;
}
mArgLen--;

AppRuntimeruntime;
constchar*arg;
argv0=argv[0];

//Processcommandlinearguments
//ignoreargv[0]
argc--;
argv++;

//Everythingupto'--'orfirstnon'-'arggoestothevm

inti=runtime.addVmArguments(argc,argv);

//Nextargisparentdirectory
if(i<argc){
runtime.mParentDir=argv[i++];
}

//Nextargisstartupclassnameor"--zygote"
if(i<argc){
arg=argv[i++];
if(0==strcmp("--zygote",arg)){
boolstartSystemServer=(i<argc)?
strcmp(argv[i],"--start-system-server")==0:false;
setArgv0(argv0,"zygote");
set_process_name("zygote");
runtime.start("com.android.internal.os.ZygoteInit",
startSystemServer);
}else{
set_process_name(argv0);

runtime.mClassName=arg;

//Remainderofargsgetpassedtostartupclassmain()
runtime.mArgC=argc-i;
runtime.mArgV=argv+i;

LOGV("Appprocessisstartingwithpid=%d,class=%s.\n",
getpid(),runtime.getClassName());
runtime.start();
}
}else{
LOG_ALWAYS_FATAL("app_process:noclassnameor--zygotesupplied.");
fprintf(stderr,"Error:noclassnameor--zygotesupplied.\n");
app_usage();
return10;
}

}

这个函数的主要作用就是创建一个AppRuntime变量，然后调用它的start成员函数。AppRuntime这个类我们在Android应用程序进程启动过程的源代码分析一文中已经有过介绍了，它同样是在frameworks/base/cmds/app_process/app_main.cpp文件中定义：

classAppRuntime:publicAndroidRuntime
{
......
};

它约继承于AndroidRuntime类，AndroidRuntime类定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

......

staticAndroidRuntime*gCurRuntime=NULL;

......

AndroidRuntime::AndroidRuntime()
{
......

assert(gCurRuntime==NULL);//oneperprocess
gCurRuntime=this;
}

当AppRuntime对象创建时，会调用其父类AndroidRuntime的构造函数，而在AndroidRuntime类的构造函数里面，会将this指针保存在静态全局变量gCurRuntime中，这样，当其它地方需要使用这个AppRuntime对象时，就可以通过同一个文件中的这个函数来获取这个对象的指针：

AndroidRuntime*AndroidRuntime::getRuntime()
{
returngCurRuntime;
}

回到上面的main函数中，由于我们在init.rc文件中，设置了app_process启动参数--zygote和--start-system-server，因此，在main函数里面，最终会执行下面语句：

runtime.start("com.android.internal.os.ZygoteInit",
rtSystemServer);

这里的参数startSystemServer为true，表示要启动SystemServer组件。由于AppRuntime没有实现自己的start函数，它继承了父类AndroidRuntime的start函数，因此，下面会执行AndroidRuntime类的start函数。

Step 2.AndroidRuntime.start

这个函数定义在frameworks/base/core/jni/AndroidRuntime.cpp文件中：

/*
*StarttheAndroidruntime.Thisinvolvesstartingthevirtualmachine
*andcallingthe"staticvoidmain(String[]args)"methodintheclass
*namedby"className".
*/
voidAndroidRuntime::start(constchar*className,constboolstartSystemServer)
{
......

char*slashClassName=NULL;
char*cp;
JNIEnv*env;

......

/*startthevirtualmachine*/
if(startVm(&mJavaVM,&env)!=0)
gotobail;

/*
*Registerandroidfunctions.
*/
if(startReg(env)<0){
LOGE("Unabletoregisterallandroidnatives\n");
gotobail;
}

/*
*Wewanttocallmain()withaStringarraywithargumentsinit.
*Atpresentweonlyhaveoneargument,theclassname.Createan
*arraytoholdit.
*/
jclassstringClass;
jobjectArraystrArray;
jstringclassNameStr;
jstringstartSystemServerStr;
stringClass=env->FindClass("java/lang/String");
assert(stringClass!=NULL);
strArray=env->NewObjectArray(2,stringClass,NULL);
assert(strArray!=NULL);
classNameStr=env->NewStringUTF(className);
assert(classNameStr!=NULL);
env->SetObjectArrayElement(strArray,0,classNameStr);
startSystemServerStr=env->NewStringUTF(startSystemServer?
"true":"false");
env->SetObjectArrayElement(strArray,1,startSystemServerStr);

/*
*StartVM.ThisthreadbecomesthemainthreadoftheVM,andwill
*notreturnuntiltheVMexits.
*/
jclassstartClass;
jmethodIDstartMeth;

slashClassName=strdup(className);
for(cp=slashClassName;*cp!='\0';cp++)
if(*cp=='.')
*cp='/';

startClass=env->FindClass(slashClassName);
if(startClass==NULL){
......
}else{
startMeth=env->GetStaticMethodID(startClass,"main",
"([Ljava/lang/String;)V");
if(startMeth==NULL){
......
}else{
env->CallStaticVoidMethod(startClass,startMeth,strArray);
......
}
}

......
}

这个函数的作用是启动Android系统运行时库，它主要做了三件事情，一是调用函数startVM启动虚拟机，二是调用函数startReg注册JNI方法，三是调用了com.android.internal.os.ZygoteInit类的main函数。

Step 3.ZygoteInit.main

这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

publicclassZygoteInit{
......

publicstaticvoidmain(Stringargv[]){
try{
......

registerZygoteSocket();

......

......

if(argv[1].equals("true")){
startSystemServer();
}elseif(!argv[1].equals("false")){
......
}

......

if(ZYGOTE_FORK_MODE){
......
}else{
runSelectLoopMode();
}

......
}catch(MethodAndArgsCallercaller){
......
}catch(RuntimeExceptionex){
......
}
}

......
}

它主要作了三件事情，一个调用registerZygoteSocket函数创建了一个socket接口，用来和ActivityManagerService通讯，二是调用startSystemServer函数来启动SystemServer组件，三是调用runSelectLoopMode函数进入一个无限循环在前面创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程。

Step 4.ZygoteInit.registerZygoteSocket

这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

publicclassZygoteInit{
......

/**
*Registersaserversocketforzygotecommandconnections
*
*@throwsRuntimeExceptionwhenopenfails
*/
privatestaticvoidregisterZygoteSocket(){
if(sServerSocket==null){
intfileDesc;
try{
Stringenv=System.getenv(ANDROID_SOCKET_ENV);
fileDesc=Integer.parseInt(env);
}catch(RuntimeExceptionex){
......
}

try{
sServerSocket=newLocalServerSocket(
createFileDescriptor(fileDesc));
}catch(IOExceptionex){
.......
}
}
}

......
}

这个socket接口是通过文件描述符来创建的，这个文件描符代表的就是我们前面说的/dev/socket/zygote文件了。这个文件描述符是通过环境变量ANDROID_SOCKET_ENV得到的，它定义为：

publicclassZygoteInit{
......

privatestaticfinalStringANDROID_SOCKET_ENV="ANDROID_SOCKET_zygote";

......
}

那么，这个环境变量的值又是由谁来设置的呢？我们知道，系统启动脚本文件system/core/rootdir/init.rc是由init进程来解释执行的，而init进程的源代码位于system/core/init目录中，在init.c文件中，是由service_start函数来解释init.rc文件中的service命令的：

voidservice_start(structservice*svc,constchar*dynamic_args)
{
......

pid_tpid;

......

pid=fork();

if(pid==0){
structsocketinfo*si;

......

for(si=svc->sockets;si;si=si->next){
intsocket_type=(
!strcmp(si->type,"stream")?SOCK_STREAM:
(!strcmp(si->type,"dgram")?SOCK_DGRAM:SOCK_SEQPACKET));
ints=create_socket(si->name,socket_type,
si->perm,si->uid,si->gid);
if(s>=0){
publish_socket(si->name,s);
}
}

......
}

......
}

每一个service命令都会促使init进程调用fork函数来创建一个新的进程，在新的进程里面，会分析里面的socket选项，对于每一个socket选项，都会通过create_socket函数来在/dev/socket目录下创建一个文件，在这个场景中，这个文件便是zygote了，然后得到的文件描述符通过publish_socket函数写入到环境变量中去：

staticvoidpublish_socket(constchar*name,intfd)
{
charkey[64]=ANDROID_SOCKET_ENV_PREFIX;
charval[64];

strlcpy(key+sizeof(ANDROID_SOCKET_ENV_PREFIX)-1,
name,
sizeof(key)-sizeof(ANDROID_SOCKET_ENV_PREFIX));
snprintf(val,sizeof(val),"%d",fd);
add_environment(key,val);

/*makesurewedon'tclose-on-exec*/
fcntl(fd,F_SETFD,0);
}

这里传进来的参数name值为"zygote"，而ANDROID_SOCKET_ENV_PREFIX在system/core/include/cutils/sockets.h定义为：

#defineANDROID_SOCKET_ENV_PREFIX"ANDROID_SOCKET_"

因此，这里就把上面得到的文件描述符写入到以"ANDROID_SOCKET_zygote"为key值的环境变量中。又因为上面的ZygoteInit.registerZygoteSocket函数与这里创建socket文件的create_socket函数是运行在同一个进程中，因此，上面的ZygoteInit.registerZygoteSocket函数可以直接使用这个文件描述符来创建一个Java层的LocalServerSocket对象。如果其它进程也需要打开这个/dev/socket/zygote文件来和Zygote进程进行通信，那就必须要通过文件名来连接这个LocalServerSocket了，参考Android应用程序进程启动过程的源代码分析一文中的Step 4，ActivityManagerService是通过Process.start函数来创建一个新的进程的，而Process.start函数会首先通过Socket连接到Zygote进程中，最终由Zygote进程来完成创建新的应用程序进程，而Process类是通过openZygoteSocketIfNeeded函数来连接到Zygote进程中的Socket的：

publicclassProcess{
......

privatestaticvoidopenZygoteSocketIfNeeded()
throwsZygoteStartFailedEx{

......

for(intretry=0
;(sZygoteSocket==null)&&(retry<(retryCount+1))
;retry++){

......

try{
sZygoteSocket=newLocalSocket();
sZygoteSocket.connect(newLocalSocketAddress(ZYGOTE_SOCKET,
LocalSocketAddress.Namespace.RESERVED));

sZygoteInputStream
=newDataInputStream(sZygoteSocket.getInputStream());

sZygoteWriter=
newBufferedWriter(
newOutputStreamWriter(
sZygoteSocket.getOutputStream()),
256);

......
}catch(IOExceptionex){
......
}
}

......
}

......
}

这里的ZYGOTE_SOCKET定义为：

publicclassProcess{
......

privatestaticfinalStringZYGOTE_SOCKET="zygote";

......
}

它刚好就是对应/dev/socket目录下的zygote文件了。

Android系统中的socket机制和binder机制一样，都是可以用来进行进程间通信，读者可以自己对比一下这两者的不同之处，Binder进程间通信机制可以参考Android进程间通信（IPC）机制Binder简要介绍和学习计划一文。

Socket对象创建完成之后，回到Step 3中的ZygoteInit.main函数中，startSystemServer函数来启动SystemServer组件。

Step 5.ZygoteInit.startSystemServer
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

publicclassZygoteInit{
......

privatestaticbooleanstartSystemServer()
throwsMethodAndArgsCaller,RuntimeException{
/*Hardcodedcommandlinetostartthesystemserver*/
Stringargs[]={
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003",
"--capabilities=130104352,130104352",
"--runtime-init",
"--nice-name=system_server",
"com.android.server.SystemServer",
};
ZygoteConnection.ArgumentsparsedArgs=null;

intpid;

try{
parsedArgs=newZygoteConnection.Arguments(args);

......

/*Requesttoforkthesystemserverprocess*/
pid=Zygote.forkSystemServer(
parsedArgs.uid,parsedArgs.gid,
parsedArgs.gids,debugFlags,null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
}catch(IllegalArgumentExceptionex){
......
}

/*Forchildprocess*/
if(pid==0){
handleSystemServerProcess(parsedArgs);
}

returntrue;
}

......
}

这里我们可以看到，Zygote进程通过Zygote.forkSystemServer函数来创建一个新的进程来启动SystemServer组件，返回值pid等0的地方就是新的进程要执行的路径，即新创建的进程会执行handleSystemServerProcess函数。

Step 6.ZygoteInit.handleSystemServerProcess
这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

publicclassZygoteInit{
......

privatestaticvoidhandleSystemServerProcess(
ZygoteConnection.ArgumentsparsedArgs)
throwsZygoteInit.MethodAndArgsCaller{
closeServerSocket();

/*
*PasstheremainingargumentstoSystemServer.
*"--nice-name=system_servercom.android.server.SystemServer"
*/
RuntimeInit.zygoteInit(parsedArgs.remainingArgs);
/*shouldneverreachhere*/
}

......
}

由于由Zygote进程创建的子进程会继承Zygote进程在前面Step 4中创建的Socket文件描述符，而这里的子进程又不会用到它，因此，这里就调用closeServerSocket函数来关闭它。这个函数接着调用RuntimeInit.zygoteInit函数来进一步执行启动SystemServer组件的操作。

Step 7.RuntimeInit.zygoteInit

这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中：

publicclassRuntimeInit{
......

publicstaticfinalvoidzygoteInit(String[]argv)
throwsZygoteInit.MethodAndArgsCaller{
......

zygoteInitNative();

......


//Remainingargumentsarepassedtothestartclass'sstaticmain

StringstartClass=argv[curArg++];
String[]startArgs=newString[argv.length-curArg];

System.arraycopy(argv,curArg,startArgs,0,startArgs.length);
invokeStaticMain(startClass,startArgs);
}

......
}

这个函数会执行两个操作，一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进程中的Binder对象就可以方便地进行进程间通信了，另一个是调用上面Step 5传进来的com.android.server.SystemServer类的main函数。

Step 8.RuntimeInit.zygoteInitNative

这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中：

publicclassRuntimeInit{
......

publicstaticfinalnativevoidzygoteInitNative();

......
}

这里可以看出，函数zygoteInitNative是一个Native函数，实现在frameworks/base/core/jni/AndroidRuntime.cpp文件中，这里我们就不再细看了，具体可以参考Android应用程序进程启动过程的源代码分析一文的Step 9，完成这一步后，这个进程的Binder进程间通信机制基础设施就准备好了。

回到Step 7中的RuntimeInit.zygoteInitNative函数，下一步它就要执行com.android.server.SystemServer类的main函数了。

Step 9.SystemServer.main

这个函数定义在frameworks/base/services/java/com/android/server/SystemServer.java文件中：

publicclassSystemServer
{
......

nativepublicstaticvoidinit1(String[]args);

......

publicstaticvoidmain(String[]args){
......

init1(args);

......
}

publicstaticfinalvoidinit2(){
Slog.i(TAG,"EnteredtheAndroidsystemserver!");
Threadthr=newServerThread();
thr.setName("android.server.ServerThread");
thr.start();
}

......
}

这里的main函数首先会执行JNI方法init1，然后init1会调用这里的init2函数，在init2函数里面，会创建一个ServerThread线程对象来执行一些系统关键服务的启动操作，例如我们在前面两篇文章Android应用程序安装过程源代码分析和Android系统默认Home应用程序（Launcher）的启动过程源代码分析中提到的PackageManagerService和ActivityManagerService。
这一步的具体执行过程可以参考Android应用程序安装过程源代码分析一文，这里就不再详述了。

这里执行完成后，层层返回，最后回到上面的Step 3中的ZygoteInit.main函数中，接下来它就要调用runSelectLoopMode函数进入一个无限循环在前面Step 4中创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程了。

Step 10.ZygoteInit.runSelectLoopMode

这个函数定义在frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件中：

publicclassZygoteInit{
......

privatestaticvoidrunSelectLoopMode()throwsMethodAndArgsCaller{
ArrayList<FileDescriptor>fds=newArrayList();
ArrayList<ZygoteConnection>peers=newArrayList();
FileDescriptor[]fdArray=newFileDescriptor[4];

fds.add(sServerSocket.getFileDescriptor());
peers.add(null);

intloopCount=GC_LOOP_COUNT;
while(true){
intindex;

......


try{
fdArray=fds.toArray(fdArray);
index=selectReadable(fdArray);
}catch(IOExceptionex){
thrownewRuntimeException("Errorinselect()",ex);
}

if(index<0){
thrownewRuntimeException("Errorinselect()");
}elseif(index==0){
ZygoteConnectionnewPeer=acceptCommandPeer();
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
}else{
booleandone;
done=peers.get(index).runOnce();

if(done){
peers.remove(index);
fds.remove(index);
}
}
}
}

......
}

这个函数我们已经在Android应用程序进程启动过程的源代码分析一文的Step 5中分析过了，这就是在等待ActivityManagerService来连接这个Socket，然后调用ZygoteConnection.runOnce函数来创建新的应用程序，有兴趣的读者可以参考Android应用程序进程启动过程的源代码分析这篇文章，这里就不再详述了。

这样，Zygote进程就启动完成了，学习到这里，我们终于都对Android系统中的进程有了一个深刻的认识了，这里总结一下：

1. 系统启动时init进程会创建Zygote进程，Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。

2. Zygote进程会首先创建一个SystemServer进程，SystemServer进程负责启动系统的关键服务，如包管理服务PackageManagerService和应用程序组件管理服务ActivityManagerService。

3. 当我们需要启动一个Android应用程序时，ActivityManagerService会通过Socket进程间通信机制，通知Zygote进程为这个应用程序创建一个新的进程。