Android系统启动2---Zygote启动及其作用

目录

1、Zygote简介

2、Zygote进程如何启动

　　2.1 init.zygote64_32.rc文件

　　2.2 查看ps信息

　　2.3 启动

3、Zygote作用

　　3.1 启动system_server

　　3.2 查看与验证Zygote启动systemserver

　　3.3 Zygote启动其他子进程

4、总结

 

1、Zygote简介

• 1.1 系统启动流程
  • 

  • 从按下电源到看到launcher，手机的启动是一个非常复杂的过程。

    bootloader是手机上电之后第一个运行的程序，其作用是硬件的初始化，其作用类似于PC机的bios。

    bootloader完成其工作后，将 Linux kernel镜像拷贝到内存中。完成剩余的与硬件平台相关的初始化工作，比如文件系统，驱动模块。最后启动第一个用户进程－init 进程并等待用户进程的执行。

    用户空间的第一个进程init
• 1.2 zygote理解
  • 在Android系统中，所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育（fork）出来的，这也许就是为什么 要把它称为Zygote（受精卵）的原因吧。由于Zygote进程在Android系统中有着如此重要的地位，本文将详细分析它的启动过程。---老罗
  • android系统中创建java世界的盘古  创建新进程的女娲。 ---邓凡平

2、Zygote进程如何启动

• 2.1 init.zygote64_32.rc文件
  • system/core/rootdir/init.zygote64_32.rc文件内容

  • service zygote /system/bin/app_process32 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
        class main
        socket zygote stream 660 root system
        onrestart write /sys/android_power/request_state wake
        onrestart write /sys/power/state on
        onrestart restart media
        onrestart restart netd
    
    service zygote_secondary /system/bin/app_process64 -Xzygote /system/bin --zygote --socket-name=zygote_secondary
        class main
        socket zygote_secondary stream 660 root system
        onrestart restart zygote

     

• 2.2 查看ps信息
  • 

  • Zygote64、Zygote是在init.rc中定义的服务进程，由init进程启动，PPID均为1。其中比较关键的vold、rild、surfaceflinger等关键进程也都是通过init进程启动的。

  • 

  • LOCAL_MULTILIB: Android.mk中用来设置编译为32位或者64位的apk，so等

• 2.3 启动
  • 
  • Zygote process main(frameworks/base/cmds/app_process/app_main.cpp)

  • int main(int argc, char* const argv[])
    {
        ...
        if (zygote) {
            runtime.start("com.android.internal.os.ZygoteInit", args);
        } else if (className) {
            runtime.start("com.android.internal.os.RuntimeInit", args);
        } else {
            fprintf(stderr, "Error: no class name or --zygote supplied.\n");
            app_usage();
            LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
            return 10;
        }
    }

     

  • 将init.rc中指定的-Xzygote参数传给JVM
    将进程的名字改为zygote（可以回答前面的问题）
    执行AppRuntime类的start()方法，runtime.start(“com.android.internal.os.ZygoteInit”, true);
    

  • void AndroidRuntime::start(const char* className, const Vector<String8>& options)
    {
        ... 
        //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
        //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
    
        /* start the virtual machine */
        JniInvocation jni_invocation;
        jni_invocation.Init(NULL);
        JNIEnv* env;
        if (startVm(&mJavaVM, &env) != 0) {
            return;
        }
        onVmCreated(env);
    
        /*
         * Register android functions.
         */
        if (startReg(env) < 0) {
            ALOGE("Unable to register all android natives\n");
            return;
        }
    
        /*
         * We want to call main() with a String array with arguments in it.
         * At present we have two arguments, the class name and an option string.
         * Create an array to hold them.
         */
        jclass stringClass;
        jobjectArray strArray;
        jstring classNameStr;
    
        stringClass = env->FindClass("java/lang/String");
        assert(stringClass != NULL);
        strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
        assert(strArray != NULL);
        classNameStr = env->NewStringUTF(className);
        assert(classNameStr != NULL);
        env->SetObjectArrayElement(strArray, 0, classNameStr);
    
        for (size_t i = 0; i < options.size(); ++i) {
            jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
            assert(optionsStr != NULL);
            env->SetObjectArrayElement(strArray, i + 1, optionsStr);
        }
    
        /*
         * Start VM.  This thread becomes the main thread of the VM, and will
         * not return until the VM exits.
         */
        char* slashClassName = toSlashClassName(className);
        jclass startClass = env->FindClass(slashClassName);
        if (startClass == NULL) {
            ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
            /* keep going */
        } else {
            jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
                "([Ljava/lang/String;)V");
            if (startMeth == NULL) {
                ALOGE("JavaVM unable to find main() in '%s'\n", className);
                /* keep going */
            } else {
                env->CallStaticVoidMethod(startClass, startMeth, strArray);
    
    #if 0
                if (env->ExceptionCheck())
                    threadExitUncaughtException(env);
    #endif
            }
        }
        free(slashClassName);
    
        ALOGD("Shutting down VM\n");
        if (mJavaVM->DetachCurrentThread() != JNI_OK)
            ALOGW("Warning: unable to detach main thread\n");
        if (mJavaVM->DestroyJavaVM() != 0)
            ALOGW("Warning: VM did not shut down cleanly\n");
    }

     

  • runtime.start函数，即在frameworks\base\core\jni\AndroidRuntime.cpp文件中
    • AndroidRuntime::startVm()中，设置一些虚拟机的参数后，通过JNI_CreateJavaVM()启动虚拟机。
    • StartReg()注册JNI 函数
    • env->CallStaticVoidMethod，调用ZygoteInit类的main()方法，正式进入到Java世界.
  • frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

  • public static void main(String argv[]) {
            try {
                ....
                registerZygoteSocket(socketName);
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                    SystemClock.uptimeMillis());
                preload();
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                    SystemClock.uptimeMillis());
    
                // Finish profiling the zygote initialization.
                SamplingProfilerIntegration.writeZygoteSnapshot();
    
                // Do an initial gc to clean up after startup
                gc();
    
                // Disable tracing so that forked processes do not inherit stale tracing tags from
                // Zygote.
                Trace.setTracingEnabled(false);
    
                if (startSystemServer) {
                    startSystemServer(abiList, socketName);
                }
    
                Log.i(TAG, "Accepting command socket connections");
                runSelectLoop(abiList);
    
                closeServerSocket();
            } catch (MethodAndArgsCaller caller) {
                caller.run();
            } catch (RuntimeException ex) {
                Log.e(TAG, "Zygote died with exception", ex);
                closeServerSocket();
                throw ex;
            }
        }

     

  • registerZygoteSocket，创建Socket服务端对象sServerSocket

    preload方法预加载类，资源等

    调用startSystemServer方法启动系统服务system_server

    runSelectLoopMode监听和处理sServerSocket的Socket请求

• 3、Zygote作用
  • 3.1 启动system_server
    • 

    • /**
           * Prepare the arguments and fork for the system server process.
           */
          private static boolean startSystemServer(String abiList, String socketName)
                  throws MethodAndArgsCaller, RuntimeException {
             ...
              int pid;
      
              try {
                  parsedArgs = new ZygoteConnection.Arguments(args);
                  ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
                  ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
      
                  /* Request to fork the system server process */
                  pid = Zygote.forkSystemServer(
                          parsedArgs.uid, parsedArgs.gid,
                          parsedArgs.gids,
                          parsedArgs.debugFlags,
                          null,
                          parsedArgs.permittedCapabilities,
                          parsedArgs.effectiveCapabilities);
              } catch (IllegalArgumentException ex) {
                  throw new RuntimeException(ex);
              }
      
              /* For child process */
              if (pid == 0) {//子进程进入
                  if (hasSecondZygote(abiList)) {
                      waitForSecondaryZygote(socketName);
                  }
      
                  handleSystemServerProcess(parsedArgs);
              }
      
              return true;
          }

    • forkSystemServer，调用Native方法fork子进程
      通过forkSystemServer方法返回的值，进入两个分支处理：父进程返回子进程pid值，进入到ZygoteInit类中的main方法继续处理；而子进程调用handleSystemServerProcess方法，最终会运行system_server。

    • /**
           * Finish remaining work for the newly forked system server process.
           */
          private static void handleSystemServerProcess(
                  ZygoteConnection.Arguments parsedArgs)
                  throws ZygoteInit.MethodAndArgsCaller {
      
              closeServerSocket();//子进程已经不是服务器了，所以关掉。
      
              // set umask to 0077 so new files and directories will default to owner-only permissions.
              Os.umask(S_IRWXG | S_IRWXO);
      
              if (parsedArgs.niceName != null) {
                  Process.setArgV0(parsedArgs.niceName);
              }
      
              final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
              if (systemServerClasspath != null) {
                  performSystemServerDexOpt(systemServerClasspath);
              }
      
              if (parsedArgs.invokeWith != null) {
                  String[] args = parsedArgs.remainingArgs;
                  // If we have a non-null system server class path, we'll have to duplicate the
                  // existing arguments and append the classpath to it. ART will handle the classpath
                  // correctly when we exec a new process.
                  if (systemServerClasspath != null) {
                      String[] amendedArgs = new String[args.length + 2];
                      amendedArgs[0] = "-cp";
                      amendedArgs[1] = systemServerClasspath;
                      System.arraycopy(parsedArgs.remainingArgs, 0, amendedArgs, 2, parsedArgs.remainingArgs.length);
                  }
      
                  WrapperInit.execApplication(parsedArgs.invokeWith,
                          parsedArgs.niceName, parsedArgs.targetSdkVersion,
                          null, args);
              } else {
                  ClassLoader cl = null;
                  if (systemServerClasspath != null) {
                      cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
                      Thread.currentThread().setContextClassLoader(cl);
                  }
      
                  /*
                   * Pass the remaining arguments to SystemServer.
                   */
                  RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
              }
      
              /* should never reach here */
          }

       

    • frameworks/base/core/java/com/android/internal/os/RuntimeInit.java

    • public class RuntimeInit {
          。。。
          private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
                  throws ZygoteInit.MethodAndArgsCaller {
             。。。
      232        throw new ZygoteInit.MethodAndArgsCaller(m, argv);
          }
          public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
                  throws ZygoteInit.MethodAndArgsCaller {
              if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");
      
              redirectLogStreams();
      
              commonInit();
              nativeZygoteInit();
      
              applicationInit(targetSdkVersion, argv, classLoader);
          }
          private static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
                  throws ZygoteInit.MethodAndArgsCaller {
              。。。
              VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
              VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
      
              。。。
              // Remaining arguments are passed to the start class's static main
              invokeStaticMain(args.startClass, args.startArgs, classLoader);
          }
          public static final IBinder getApplicationObject() {
              return mApplicationObject;
          }
      }

       

    • public static void main(String argv[]) {
              try {
                  。。。
                  if (startSystemServer) {
                      startSystemServer(abiList, socketName);
                  }
                  。。。//然而并没有机会进入循环
              } catch (MethodAndArgsCaller caller) {
      51             caller.run();
              } catch (RuntimeException ex) {
                  Log.e(TAG, "Zygote died with exception", ex);
                  closeServerSocket();
                  throw ex;
              }
          }

       

    • 这个函数会执行两个操作，一个是调用zygoteInitNative函数来执行一个Binder进程间通信机制的初始化工作，这个工作完成之后，这个进 程中的Binder对象就可以方便地进行进程间通信了，另一个是调用上面传进来的com.android.server.SystemServer类的main函数。
  • 3.2 查看与验证Zygote启动systemserver
    
    • 
    • 
    • ps进程信息，验证system_server是Zygote的分裂出的第一个子进程.
  • 3.3 Zygote启动其他子进程
    
    • 
    • 注意：重复的不再涉及，我们只是分析一下7-12吧。
    • frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

    • /**
           * 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.
           *
           * @throws MethodAndArgsCaller in a child process when a main() should
           * be executed.
           */
          private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
              。。。
              while (true) {
                  。。。
                  try {
                      fdArray = fds.toArray(fdArray);
                      index = selectReadable(fdArray);
                  } catch (IOException ex) {
                      throw new RuntimeException("Error in select()", ex);
                  }
      
                  if (index < 0) {
                      throw new RuntimeException("Error in select()");
                  } else if (index == 0) {
                      ZygoteConnection newPeer = acceptCommandPeer(abiList);
                      peers.add(newPeer);
                      fds.add(newPeer.getFileDescriptor());
                  } else {
                      boolean done;
                      done = peers.get(index).runOnce();
      
                      if (done) {
                          peers.remove(index);
                          fds.remove(index);
                      }
                  }
              }
          }

       

    • runSelectLoopMode中while(true)循环，接收到Socket请求后，会fork出子进程，子进程调用handleChildProc方法，最终抛出RuntimeInit.invokeStaticMain异常，退出while(true)循环（与fork Systemserver不一样，后者没有进入循环），进入到android.app.ActivityThread类的main方法执行；父进程调用handleParentProc方法，再次进入runSelectLoopMode中while(true)循环，准备接收下一个的请求事件。
    • frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java

    • boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
        　　       ...
              try {
                  ...
                  pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                          parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                          parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                          parsedArgs.appDataDir);
                  checkTime(startTime, "zygoteConnection.runOnce: postForkAndSpecialize");
              } catch (IOException ex) {
                  logAndPrintError(newStderr, "Exception creating pipe", ex);
              } catch (ErrnoException ex) {
                  logAndPrintError(newStderr, "Exception creating pipe", ex);
              } catch (IllegalArgumentException ex) {
                  logAndPrintError(newStderr, "Invalid zygote arguments", ex);
              } catch (ZygoteSecurityException ex) {
                  logAndPrintError(newStderr,
                          "Zygote security policy prevents request: ", ex);
              }
      
              try {
                  if (pid == 0) {
                      // in child
                      IoUtils.closeQuietly(serverPipeFd);
                      serverPipeFd = null;
                      handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
      
                      // should never get here, the child is expected to either
                      // throw ZygoteInit.MethodAndArgsCaller or exec().
                      return true;
                  } else {
                      // in parent...pid of < 0 means failure
                      IoUtils.closeQuietly(childPipeFd);
                      childPipeFd = null;
                      return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
                  }
              } finally {
                  IoUtils.closeQuietly(childPipeFd);
                  IoUtils.closeQuietly(serverPipeFd);
              }
          }

       

    • 10和11略过，只是返回而已。我们现在进入子进程的handleChildProc。

    • private void handleChildProc(Arguments parsedArgs,
                  FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)
                  throws ZygoteInit.MethodAndArgsCaller {
      
              /**
               * By the time we get here, the native code has closed the two actual Zygote
               * socket connections, and substituted /dev/null in their place.  The LocalSocket
               * objects still need to be closed properly.
               */
      
              closeSocket();
              ZygoteInit.closeServerSocket();
      
              。。。 
                  if (parsedArgs.invokeWith != null) {
                      WrapperInit.execStandalone(parsedArgs.invokeWith,
                              parsedArgs.classpath, className, mainArgs);
                  } else {
                      ClassLoader cloader;
                      if (parsedArgs.classpath != null) {
                          cloader = new PathClassLoader(parsedArgs.classpath,
                                  ClassLoader.getSystemClassLoader());
                      } else {
                          cloader = ClassLoader.getSystemClassLoader();
                      }
      
                      try {
                          ZygoteInit.invokeStaticMain(cloader, className, mainArgs);
                      } catch (RuntimeException ex) {
                          logAndPrintError(newStderr, "Error starting.", ex);
                      }
                  }
              。。。
          }

    • 剩余的就和上面雷同了，这里不再分析。

4、总结

• 系统启动时init进程会创建Zygote进程，Zygote进程负责后续Android应用程序框架层的其它进程的创建和启动工作。（可以使用ps查看）

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

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

•