Android4.4的zygote进程（下）

3.2.4启动Android系统服务——startSystemServer()

接下来就是启动Android的重头戏了，此时ZygoteInit的main()函数会调用startSystemServer()，该函数用于启动整个Android系统的系统服务。其大体做法是先fork一个子进程，然后在子进程中做一些初始化动作，继而执行SystemServer类的main()静态函数。需要注意的是，startSystemServer()并不是在函数体内直接调用Java类的main()函数的，而是通过抛异常的方式，在startSystemServer()之外加以处理的。

startSystemServer()的代码如下：

1. private static boolean startSystemServer()
2. throws MethodAndArgsCaller, RuntimeException
3. {
4. . . . . . .
5. /* Hardcoded command line to start the system server */
6. String args[] = {
7. "--setuid=1000",
8. "--setgid=1000",
9. "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,
10. 3001,3002,3003,3006,3007",
11. "--capabilities=" + capabilities + "," + capabilities,
12. "--runtime-init",
13. "--nice-name=system_server",
14. "com.android.server.SystemServer",
15. };
16. ZygoteConnection.Arguments parsedArgs = null;
17. int pid;
18. try {
19. parsedArgs = new ZygoteConnection.Arguments(args);
20. ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
21. ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
22. // fork出系统服务对应的进程
23. pid = Zygote.forkSystemServer(parsedArgs.uid, parsedArgs.gid,
24. parsedArgs.gids, parsedArgs.debugFlags, null,
25. parsedArgs.permittedCapabilities,
26. parsedArgs.effectiveCapabilities);
27. } catch (IllegalArgumentException ex) {
28. throw new RuntimeException(ex);
29. }
30. // 对新fork出的系统进程，执行handleSystemServerProcess()
31. if (pid == 0) {
32. handleSystemServerProcess(parsedArgs);
33. }
34. return true;
35. }

 

args[]中的字符串	对应
"--setuid=1000"	parsedArgs.uid
"--setgid=1000"	parsedArgs.gid
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008, 1009,1010,1018,1021,1032,3001,3002,3003,3006,3007"	parsedArgs.gids
"--capabilities=" + capabilities + "," + capabilities	capabilitiesSpecified = true; permittedCapabilities = Long.decode(capStrings[0]); effectiveCapabilites = Long.decode(capString[1]);
"--runtime-init"	parsedArgs.runtimeInit设为true
"--nice-name=system_server"	parsedArgs.niceName
"com.android.server.SystemServer"	parsedArgs.remainingArgs

3.2.4.1Zygote.forkSystemServer()

Zygote.forkSystemServer()的代码如下：
【libcore/dalvik/src/main/java/dalvik/system/Zygote.java】

1. public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
2. int[][] rlimits, long permittedCapabilities, long effectiveCapabilities)
3. {
4. preFork();
5. int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits,
6. permittedCapabilities, effectiveCapabilities);
7. postFork();
8. return pid;
9. }

其中的nativeForkSystemServer()是个native成员函数，其对应的C++层函数为Dalvik_dalvik_system_Zygote_forkSystemServer()。

【dalvik/vm/native/dalvik_system_Zygote.cpp】

1. const DalvikNativeMethod dvm_dalvik_system_Zygote[] = {
2. { "nativeFork", "()I",
3. Dalvik_dalvik_system_Zygote_fork },
4. { "nativeForkAndSpecialize", "(II[II[[IILjava/lang/String;Ljava/lang/String;)I",
5. Dalvik_dalvik_system_Zygote_forkAndSpecialize },
6. { "nativeForkSystemServer", "(II[II[[IJJ)I",
7. Dalvik_dalvik_system_Zygote_forkSystemServer },
8. { NULL, NULL, NULL },
9. };

 

1. static void Dalvik_dalvik_system_Zygote_forkSystemServer(
2. const u4* args, JValue* pResult)
3. {
4. pid_t pid;
5. pid = forkAndSpecializeCommon(args, true);
6. if (pid > 0) {
7. int status;
8. ALOGI("System server process %d has been created", pid);
9. gDvm.systemServerPid = pid;
10. if (waitpid(pid, &status, WNOHANG) == pid) {
11. ALOGE("System server process %d has died. Restarting Zygote!", pid);
12. kill(getpid(), SIGKILL);
13. }
14. }
15. RETURN_INT(pid);
16. }

forkAndSpecializeCommon()内部其实会调用fork()，而后设置gid、uid等信息。

3.2.4.2SystemServer的handleSystemServerProgress()函数

接着，startSystemServer()会在新fork出的子进程中调用handleSystemServerProgress()，让这个新进程成为真正的系统进程（SystemServer进程）。

1. // 对新fork出的系统进程，执行handleSystemServerProcess()
2. if (pid == 0) {
3. handleSystemServerProcess(parsedArgs);
4. }

注意，调用handleSystemServerProcess()时，程序是运行在新fork出的进程中的。handleSystemServerProcess()的代码如下：

【frameworks/base/core/java/com/android/internal/os/ZygoteInit.java】

1. private static void handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs)
2. throws ZygoteInit.MethodAndArgsCaller
3. {
4. closeServerSocket();
5. Libcore.os.umask(S_IRWXG | S_IRWXO);
6. if (parsedArgs.niceName != null) {
7. Process.setArgV0(parsedArgs.niceName);  // niceName就是”system_server”
8. }
9. if (parsedArgs.invokeWith != null) {
10. WrapperInit.execApplication(parsedArgs.invokeWith,
11. parsedArgs.niceName, parsedArgs.targetSdkVersion,
12. null, parsedArgs.remainingArgs);
13. } else {
14. // 此时的remainingArgs就是”com.android.server.SystemServer”
15. RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);
16. }
17. }

 

3.2.4.2.1closeServerSocket()

因为当前已经不是运行在zygote进程里了，所以zygote里的那个监听socket就应该关闭了。这就是closeServerSocket()的意义，其代码如下：

1. static void closeServerSocket()
2. {
3. try {
4. if (sServerSocket != null) {
5. FileDescriptor fd = sServerSocket.getFileDescriptor();
6. sServerSocket.close();
7. if (fd != null) {
8. Libcore.os.close(fd);
9. }
10. }
11. } catch (IOException ex) {
12. Log.e(TAG, "Zygote:  error closing sockets", ex);
13. } catch (libcore.io.ErrnoException ex) {
14. Log.e(TAG, "Zygote:  error closing descriptor", ex);
15. }
16. sServerSocket = null;
17. }

在handleSystemServerProcess()函数里，parsedArgs.niceName就是“system_server”，而且因为parsedArgs.invokeWith没有指定，所以其值为null，于是程序会走到RuntimeInit.zygoteInit()。

3.2.4.2.2RuntimeInit.zygoteInit()

RuntimeInit.zygoteInit()的代码如下：
【frameworks/base/core/java/com/android/internal/os/RuntimeInit.java】

1. public static final void zygoteInit(int targetSdkVersion, String[] argv)
2. throws ZygoteInit.MethodAndArgsCaller
3. {
4. if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
5. redirectLogStreams();
6. commonInit();
7. nativeZygoteInit();
8. applicationInit(targetSdkVersion, argv);
9. }

 

3.2.4.2.2.1.调用redirectLogStreams()

首先，在新fork出的系统进程里，需要重新定向系统输出流。

1. public static void redirectLogStreams()
2. {
3. System.out.close();
4. System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));
5. System.err.close();
6. System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));
7. }

 

3.2.4.2.2.2.调用commonInit()

1. private static final void commonInit()
2. {
3. . . . . . .
4. Thread.setDefaultUncaughtExceptionHandler(new UncaughtHandler());
5. TimezoneGetter.setInstance(new TimezoneGetter()
6. . . . . . .
7. . . . . . .
8. String trace = SystemProperties.get("ro.kernel.android.tracing");
9. . . . . . .
10. initialized = true;
11. }

当前正处于系统进程的主线程中，可以调用Thread.setDefaultUncaughtExceptionHandler()来设置一个默认的异常处理器，处理程序中的未捕获异常。其他的初始化动作，我们暂不深究。

3.2.4.2.2.3.调用nativeZygoteInit()

接下来调用的nativeZygoteInit()是个JNI函数，在AndroidRuntime.cpp文件中可以看到：
【frameworks/base/core/jni/AndroidRuntime.cpp】

1. static JNINativeMethod gMethods[] = {
2. { "nativeFinishInit", "()V",
3. (void*) com_android_internal_os_RuntimeInit_nativeFinishInit },
4. { "nativeZygoteInit", "()V",
5. (void*) com_android_internal_os_RuntimeInit_nativeZygoteInit },
6. { "nativeSetExitWithoutCleanup", "(Z)V",
7. (void*) com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup },
8. };

nativeZygoteInit()对应的本地函数为com_android_internal_os_RuntimeInit_nativeZygoteInit()。

1. static void com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
2. {
3. gCurRuntime->onZygoteInit();
4. }

gCurRuntime是C++层的AndroidRuntime类的静态变量。在AndroidRuntime构造之时，

gCurRuntime = this。不过实际调用的onZygoteInit()应该是AndroidRuntime的子类AppRuntime的：
【frameworks/base/cmds/app_process/App_main.cpp】

1. class AppRuntime : public AndroidRuntime
2. {
3. . . . . . .
4. virtual void onZygoteInit()
5. {
6. // Re-enable tracing now that we're no longer in Zygote.
7. atrace_set_tracing_enabled(true);
8. sp<ProcessState> proc = ProcessState::self();
9. ALOGV("App process: starting thread pool.\n");
10. proc->startThreadPool();
11. }

里面构造了进程的ProcessState全局对象，而且启动了线程池。

ProcessState对象是典型的单例模式，它的self()函数如下：

1. sp<ProcessState> ProcessState::self()
2. {
3. Mutex::Autolock _l(gProcessMutex);
4. if (gProcess != NULL) {
5. return gProcess;
6. }
7. gProcess = new ProcessState;
8. return gProcess;
9. }

ProcessState对于Binder通信机制而言非常重要，现在system server进程的PrecessState算是初始化完毕了。

我们整理一下思路，画一张startSystemServer()的调用关系图：

接下来我们来讲上图中zygoteInit()调用的最后一行：applicationInit()。

3.2.4.2.2.4.调用applicationInit()

applicationInit()函数的代码如下：
【frameworks/base/core/java/com/android/internal/os/RuntimeInit.java】

1. private static void applicationInit(int targetSdkVersion, String[] argv)
2. throws ZygoteInit.MethodAndArgsCaller
3. {
4. nativeSetExitWithoutCleanup(true);
5. VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
6. VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
7. final Arguments args;
8. try {
9. args = new Arguments(argv);
10. } catch (IllegalArgumentException ex) {
11. Slog.e(TAG, ex.getMessage());
12. return;
13. }
14. invokeStaticMain(args.startClass, args.startArgs);
15. }

其中的invokeStaticMain()一句最为关键，它承担向外抛出“特殊异常”的作用。我们先画一张startSystemServer()的调用关系图：

看到了吧，最后一步抛出了异常。这相当于一个“特殊的goto语句”！上面的cl = Class.forName(className)一句，其实加载的就是SystemServer类。这个类名是从前文的parsedArgs.remainingArgs得来的，其值就是“com.android.server.SystemServer”。此处抛出的异常，会被本进程的catch语句接住，在那里才会执行SystemServer类的main()函数。示意图如下：

如上图所示，新fork出的SystemServer子进程直接跳过了中间那句runSelectLoop()，径直跳转到caller.run()一步了。

当然，父进程Zygote在fork动作后，会退出startSystemServer()函数，并走到runSelectLoop()，从而进入一种循环监听状态，每当Activity Manager Service向它发出“启动新应用进程”的命令时，它又会fork一个子进程，并在子进程里抛出一个异常，这样子进程还是会跳转到catch一句。

我们可以把上面的示意图再丰富一下：

还有一点需要说明一下，fork出的SystemServer进程在跳转到catch语句后，会执行SystemServer类的main()函数，而其他情况下，fork出的应用进程在跳转的catch语句后，则会执行ActivityThread类的main()函数。这个ActivityThread对于应用程序而言非常重要，但因为和本篇主题关系不大，我们就不在这里展开讲了。

3.2.4.3 SystemServer的main()函数

前文我们已经看到了，startSystemServer()创建的新进程在执行完applicationInit()之后，会抛出一个异常，并由新fork出的SystemServer子进程的catch语句接住，继而执行SystemServer类的main()函数。

那么SystemServer的main()函数又在做什么事情呢？其调用关系图如下：

在Android4.4版本中，ServerThread已经不再继承于Thread了，它现在只是个辅助类，其命名还残留有旧代码的味道。在以前的Android版本中，ServerThread的确继承于Thread，而且在线程的run()成员函数里，做着类似addService、systemReady的工作。

因为本文主要是阐述zygote进程的，所以我们就不在这里继续细说system server进程啦，有兴趣的同学可以继续研究。我们还是回过头继续说zygote里的动作吧。

3.2.5监听zygote socket

3.2.5.1runSelectLoop()

ZygoteInit的main()函数在调用完startSystemServer()之后，会进一步走到runSelectLoop()。runSelectInit()的代码如下：
【frameworks/base/core/java/com/android/internal/os/ZygoteInit.java】

1. private static void runSelectLoop() throws MethodAndArgsCaller
2. {
3. ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
4. ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
5. FileDescriptor[] fdArray = new FileDescriptor[4];
6. fds.add(sServerSocket.getFileDescriptor());
7. peers.add(null);
8. int loopCount = GC_LOOP_COUNT;
9. while (true) {
10. int index;
11. if (loopCount <= 0) {
12. gc();
13. loopCount = GC_LOOP_COUNT;
14. } else {
15. loopCount--;
16. }
17. try {
18. fdArray = fds.toArray(fdArray);
19. index = selectReadable(fdArray);
20. } catch (IOException ex) {
21. throw new RuntimeException("Error in select()", ex);
22. }
23. if (index < 0) {
24. throw new RuntimeException("Error in select()");
25. } else if (index == 0) {
26. ZygoteConnection newPeer = acceptCommandPeer();
27. peers.add(newPeer);
28. fds.add(newPeer.getFileDesciptor());
29. } else {
30. boolean done;
31. done = peers.get(index).runOnce();
32. if (done) {
33. peers.remove(index);
34. fds.remove(index);
35. }
36. }
37. }
38. }

在一个while循环中，不断调用selectReadable()。该函数是个native函数，对应C++层的com_android_internal_os_ZygoteInit_selectReadable()。

【frameworks/base/core/jni/com_android_internal_os_ZygoteInit.cpp】

1. static jint com_android_internal_os_ZygoteInit_selectReadable (JNIEnv *env, jobject clazz,
2. jobjectArray fds)
3. {
4. . . . . . .
5. int err;
6. do {
7. err = select (nfds, &fdset, NULL, NULL, NULL);
8. } while (err < 0 && errno == EINTR);
9. . . . . . .
10. for (jsize i = 0; i < length; i++) {
11. jobject fdObj = env->GetObjectArrayElement(fds, i);
12. . . . . . .
13. int fd = jniGetFDFromFileDescriptor(env, fdObj);
14. . . . . . .
15. if (FD_ISSET(fd, &fdset)) {
16. return (jint)i;
17. }
18. }
19. return -1;
20. }

可以看到，主要就是调用select()而已。在Linux的socket编程中，select()负责监视若干文件描述符的变化情况，我们常见的变化情况有：读、写、异常等等。在zygote中，

err = select (nfds, &fdset, NULL, NULL, NULL);一句的最后三个参数都为NULL，表示该select()操作只打算监视文件描述符的“读变化”，而且如果没有可读的文件，select()就维持阻塞状态。

在被监视的文件描述符数组（fds）中，第一个文件描述符对应着“zygote接收其他进程连接申请的那个socket（及sServerSocket）”，一旦它发生了变化，我们就尝试建立一个ZygoteConnection。

1. // (index == 0)的情况
2. ZygoteConnection newPeer = acceptCommandPeer();
3. peers.add(newPeer);
4. fds.add(newPeer.getFileDesciptor());

看到了吗，新创建的ZygoteConnection会被再次写入文件描述符数组（fds）。

如果select动作发现文件描述符数组（fds）的其他文件描述符有东西可读了，说明有其他进程通过某个已建立好的ZygoteConnection发来了命令，此时我们需要调用runOnce()。

1. // (index > 0)的情况
2. boolean done;
3. done = peers.get(index).runOnce();
4. if (done) {
5. peers.remove(index);
6. fds.remove(index);
7. }

建立ZygoteConnection的acceptCommandPeer()的代码如下：

1. private static ZygoteConnection acceptCommandPeer() {
2. try {
3. return new ZygoteConnection(sServerSocket.accept());
4. } catch (IOException ex) {
5. throw new RuntimeException(
6. "IOException during accept()", ex);
7. }
8. }

 

3.2.5.1.1ZygoteConnection的runOnce()

ZygoteConnection的runOnce()代码截选如下：

1. boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
2. String args[];
3. Arguments parsedArgs = null;
4. FileDescriptor[] descriptors;
5. . . . . . .
6. args = readArgumentList();
7. descriptors = mSocket.getAncillaryFileDescriptors();
8. . . . . . .
9. int pid = -1;
10. FileDescriptor childPipeFd = null;
11. FileDescriptor serverPipeFd = null;
12. try {
13. parsedArgs = new Arguments(args);
14. . . . . . .
15. pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
16. parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal,
17. parsedArgs.seInfo, parsedArgs.niceName);
18. }
19. . . . . . .
20. if (pid == 0) {
21. // in child
22. IoUtils.closeQuietly(serverPipeFd);
23. serverPipeFd = null;
24. handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
25. return true;
26. } else {
27. // in parent...pid of < 0 means failure
28. IoUtils.closeQuietly(childPipeFd);
29. childPipeFd = null;
30. return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
31. }
32. . . . . . .
33. }

 

3.2.5.1.2readArgumentList()

runOnce()中从socket中读取参数数据的动作是由readArgumentList()完成的，该函数的代码如下：

1. private String[] readArgumentList()
2. throws IOException
3. {
4. int argc;
5. . . . . . .
6. String s = mSocketReader.readLine();
7. . . . . . .
8. argc = Integer.parseInt(s);
9. . . . . . .
10. String[] result = new String[argc];
11. for (int i = 0; i < argc; i++) {
12. result[i] = mSocketReader.readLine();
13. if (result[i] == null) {
14. // We got an unexpected EOF.
15. throw new IOException("truncated request");
16. }
17. }
18. return result;
19. }

可是是谁在向这个socket写入参数的呢？当然是AMS啦。

我们知道，当AMS需要启动一个新进程时，会调用类似下面的句子：

1. Process.ProcessStartResult startResult = Process.start("android.app.ActivityThread",
2. app.processName, uid, uid, gids, debugFlags, mountExternal,
3. app.info.targetSdkVersion, app.info.seinfo, null);

包括ActivityThread类名等重要信息的参数，最终就会通过socket传递给zygote。

3.2.5.1.3handleChildProc()

runOnce()在读完参数之后，会进一步调用到handleChildProc()。正如前文所说，该函数会间接抛出特殊的MethodAndArgsCaller异常，只不过此时抛出的异常携带的类名为ActivityThread。

1. private void handleChildProc(Arguments parsedArgs, FileDescriptor[] descriptors,
2. FileDescriptor pipeFd, PrintStream newStderr)
3. throws ZygoteInit.MethodAndArgsCaller
4. {
5. closeSocket();
6. ZygoteInit.closeServerSocket();
7. . . . . . .
8. if (parsedArgs.niceName != null) {
9. Process.setArgV0(parsedArgs.niceName);
10. }
11. if (parsedArgs.runtimeInit) {
12. if (parsedArgs.invokeWith != null) {
13. WrapperInit.execApplication(parsedArgs.invokeWith,
14. parsedArgs.niceName, parsedArgs.targetSdkVersion,
15. pipeFd, parsedArgs.remainingArgs);
16. } else {
17. RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,
18. parsedArgs.remainingArgs);
19. }
20. } else {
21. String className;
22. . . . . . .
23. className = parsedArgs.remainingArgs[0];
24. . . . . . .
25. String[] mainArgs = new String[parsedArgs.remainingArgs.length - 1];
26. System.arraycopy(parsedArgs.remainingArgs, 1,
27. mainArgs, 0, mainArgs.length);
28. if (parsedArgs.invokeWith != null) {
29. WrapperInit.execStandalone(parsedArgs.invokeWith,
30. parsedArgs.classpath, className, mainArgs);
31. } else {
32. ClassLoader cloader;
33. if (parsedArgs.classpath != null) {
34. cloader = new PathClassLoader(parsedArgs.classpath,
35. ClassLoader.getSystemClassLoader());
36. } else {
37. cloader = ClassLoader.getSystemClassLoader();
38. }
39. try {
40. ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
41. } catch (RuntimeException ex) {
42. logAndPrintError(newStderr, "Error starting.", ex);
43. }
44. }
45. }
46. }

 

4小结

至此，zygote进程就阐述完毕了。作为一个最原始的“受精卵”，它必须在合适的时机进行必要的细胞分裂。分裂动作也没什么大的花样，不过就是fork()新进程而已。如果fork()出的新进程是system server，那么其最终执行的就是SystemServer类的main()函数，而如果fork()出的新进程是普通的用户进程的话，那么其最终执行的就是ActivityThread类的main()函数。有关ActivityThread的细节，我们有时间再深入探讨，这里就不细说了。

本篇文章和我的上一篇文章《Android4.4的init进程》可以算是姊妹篇啦。读完这两篇文章，我相信大家对Android的启动流程能有一些大面上的认识了。

转自http://blog.csdn.net/codefly/article/details/48413829