你的位置:首页 > 操作系统

[操作系统]ZygoteInit 相关分析


上一篇文章我们已经分析到调用com.android.internal.os.ZygoteInit类的main函数。

今天分析一下com.android.internal.os.ZygoteInit类的main函数。

public static void main(String argv[]) {    // 注册zygote的socket
    registerZygoteSocket(); /** * 处理客户端连接及请求。由zygoteConnection的runOnce函数来处理。
    */ runSelectLoopMode();
}

在main函数我们就主要看registerZygoteSocket()与runSelectLoopMode()。

  • registerZygoteSocket():就是创建一个localsocket,也就是说注册了一个zygote的服务端socket。
  • runSelectLoopMode():就是一直无限循环,等待客户端socket的连接,然后通过zygoteConnection的runOnce函数来处理对应的请求。

那么我们就看一下registerZygoteSocket()

private static void registerZygoteSocket() {       String env = System.getenv(ANDROID_SOCKET_ENV);    fileDesc = Integer.parseInt(env);        if (sServerSocket == null) {       sServerSocket = new LocalServerSocket(           createFileDescriptor(fileDesc));    }}

很简单就是创建一个LocalServerSocket。

建立IPC通信服务器,从环境变量中获取(System.getenv(ANDROID_SOCKET_ENV);)socket的fd,之前用sig的fd来调用handle去创建的zygote。

这里没有提到

  • 预加载(preload)类和资源:

       PreloadClass读取framework/base/tools/preload/preload_class文件约1268类。

         PreloadResources加载framework-res.apk中的资源。

  • gc():执行垃圾收集

了解一下就好。

 

我们在来看一下runSelectLoopMode()

private static void runSelectLoopMode() throws MethodAndArgsCaller {    …    while (true) {       int index;       fdArray = fds.toArray(fdArray);       index = selectReadable(fdArray);       if(index == 0) {           //连接客户端发送的请求(Command)           ZygoteConnection newPeer = acceptCommandPeer();           peers.add(newPeer);           fds.add(newPeer.getFileDesciptor());       } else {           //处理客户端发送的请求(Command)           boolean done;           done = peers.get(index).runOnce();          }      }}

这个函数也很简单等待客户端发来的请求,当接收到请求时就运行run0nce函数去处理请求即可。

客户端可以理解成AMS或SystemServer。

在这里简单说明一下AMS与SystemServer

  • SystemServer

      Zygote的子进程,为JAVA世界做服务。

      Java世界系统Service,此进程是framework的核心,此server挂掉了,zygote会自杀。

     Zygote.forkSystemServer()而诞生。

  • AMS

    ActivityManagerService是由SystemServer创建。

    当一个Acitvity开启的时候,是由AMS中开启一个新的Process,而在Process类中最终会创建一个LocalSocket去连接ZYGOTE_SOCKET。

      而在AMS中的startProcessLocked()中调用Process.start()函数中会传入一个参数-android.app.ActivityThread。最终会通过socket传入zygote处理。

 

我们继续看以下done = peers.get(index).runOnce();

boolean runOnce( ) {    Arguments parsedArgs = null;    FileDescriptor[] descriptors;    //Reads command socket.    args = readArgumentList();    descriptors = mSocket.getAncillaryFileDescriptors();    try {       parsedArgs = new Arguments(args);        ......        pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,           parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,           parsedArgs.niceName);     } catch (IOException ex) {       ......     } catch (ErrnoException ex) {       ......     } catch (IllegalArgumentException ex) {       ......     } catch (ZygoteSecurityException ex) {       ......     }         //新创建的进程 pid == 0
if (pid == 0) { // in child serverPipeFd = null; handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr); return true; } else { // in parent,也就是Zygote进程执行过程
childPipeFd = null; return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs); }}

我们分析一下以下几个函数

  • readArgumentList()与parsedArgs = new Arguments(args) 是用来获取command和解析command的。
  • Zygote.forkAndSpecialize()是很简单的,就是去调用native函数来fork的。
  • handleChildProc()是处理子进程。
  • handleParentProc()是处理父进程。也就是zygote进程,此函数会原路返回,通过socket的写入返还给systemserver最终到AMS,然后重新进入runSelectLoopMode。

首先我们来看一下forkAndSpecialize()

这个函数定义在文件libcore/dalvik/src/main/java/dalvik/system/Zygote.java中。

public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,       int[][] rlimits, int mountExternal, String seInfo, String niceName) {     preFork();     int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName);     postFork();     return pid;   }

很简单就是调用native的ForkAndSpecialize函数。
JNI函数nativeForkAndSpecialize的由Dalvik_dalvik_system_Zygote_forkAndSpecialize函数来实现。

 

那我们就去看一下。

这个函数定义在文件dalvik/vm/native/dalvik_system_Zygote.cpp中。

static void Dalvik_dalvik_system_Zygote_forkAndSpecialize(const u4* args, JValue* pResult) { 
pid_t pid;
  //args指向的一块内存中 pid = forkAndSpecializeCommon(args, false); RETURN_INT(pid); }

Dalvik_dalvik_system_Zygote_forkAndSpecialize函数通过调用forkAndSpecializeCommon函数来执行创建进程,

实现如下所示:

这个函数定义在文件dalvik/vm/native/dalvik_system_Zygote.cpp中。

static pid_t forkAndSpecializeCommon(const u4* args, bool isSystemServer){  pid_t pid;  uid_t uid = (uid_t) args[0];  gid_t gid = (gid_t) args[1];  ......  char *seInfo = NULL;  char *niceName = NULL;  if (isSystemServer) {      //参数isSystemServer表示true时创建的是System Server进程。
  ...... } else {      //参数isSystemServer表示true时创建的是应用程序进程。
  ...... } ...... pid = fork();  //表示当前是新创建的进程 if (pid == 0) { ...... err = setSELinuxContext(uid, isSystemServer, seInfo, niceName); ...... } ...... return pid;}

我们不去看具体代码实现,主要了解一下主要是干什么的就可以了。
我们要知道的是zygote是负责应用程序进程与SystemServer的进程就可以了。

 

接下来我们回到之前的handleParentProc()

private boolean handleParentProc(int pid,     FileDescriptor[] descriptors, FileDescriptor pipeFd, Arguments parsedArgs) {   if (pid > 0) {     setChildPgid(pid);   }   if (descriptors != null) {     for (FileDescriptor fd: descriptors) {       IoUtils.closeQuietly(fd);     }   }   boolean usingWrapper = false;   if (pipeFd != null && pid > 0) {     DataInputStream is = new DataInputStream(new FileInputStream(pipeFd));     int innerPid = -1;     try {       innerPid = is.readInt();     } catch (IOException ex) {       Log.w(TAG, "Error reading pid from wrapped process, child may have died", ex);     } finally {       try {         is.close();       } catch (IOException ex) {       }     }     // Ensure that the pid reported by the wrapped process is either the     // child process that we forked, or a descendant of it.     if (innerPid > 0) {       int parentPid = innerPid;       while (parentPid > 0 && parentPid != pid) {         parentPid = Process.getParentPid(parentPid);       }       if (parentPid > 0) {         Log.i(TAG, "Wrapped process has pid " + innerPid);         pid = innerPid;         usingWrapper = true;       } else {         Log.w(TAG, "Wrapped process reported a pid that is not a child of "             + "the process that we forked: childPid=" + pid             + " innerPid=" + innerPid);       }     }   }   //将创建的应用程序进程ID返回给SystemServer进程的ActivityManagerService服务   try {     mSocketOutStream.writeInt(pid);     mSocketOutStream.writeBoolean(usingWrapper);   } catch (IOException ex) {     Log.e(TAG, "Error reading from command socket", ex);     return true;   }   /*   * If the peer wants to use the socket to wait on the   * newly spawned process, then we're all done.   */   if (parsedArgs.peerWait) {     try {       mSocket.close();     } catch (IOException ex) {       Log.e(TAG, "Zygote: error closing sockets", ex);     }     return true;   }   return false; } 

也就是创建失败会进入此函数,也就是处理zygote进程的函数,此函数会原路返回,通过socket的写入返还给systemserver最终到AMS,然后重新进入runSelectLoopMode。继续监听客户端的请求。

如果我们新创建进程成功了,会调用handleChildProc()。

代码如下

private void handleChildProc(Arguments parsedArgs,     FileDescriptor[] descriptors, FileDescriptor pipeFd, PrintStream newStderr)     throws ZygoteInit.MethodAndArgsCaller {   /*   * Close the socket, unless we're in "peer wait" mode, in which   * case it's used to track the liveness of this process.   */    if (parsedArgs.peerWait) {     try {       ZygoteInit.setCloseOnExec(mSocket.getFileDescriptor(), true);       sPeerWaitSocket = mSocket;     } catch (IOException ex) {       Log.e(TAG, "Zygote Child: error setting peer wait "           + "socket to be close-on-exec", ex);     }   } else {//关闭从Zygote进程复制过来的Socket连接     closeSocket();     ZygoteInit.closeServerSocket();   }   if (descriptors != null) {     try {       //为新创建的应用程序进程重新打开标准输入输出控制台       ZygoteInit.reopenStdio(descriptors[0],descriptors[1], descriptors[2]);       for (FileDescriptor fd: descriptors) {         IoUtils.closeQuietly(fd);       }       newStderr = System.err;     } catch (IOException ex) {       Log.e(TAG, "Error reopening stdio", ex);     }   }   //设置新进程名称   if (parsedArgs.niceName != null) {     //设置新进程名称niceName是指systemServer
Process.setArgV0(parsedArgs.niceName); } //重新初始化Runtime if (parsedArgs.runtimeInit) { if (parsedArgs.invokeWith != null) { WrapperInit.execApplication(parsedArgs.invokeWith, parsedArgs.niceName, parsedArgs.targetSdkVersion, pipeFd, parsedArgs.remainingArgs); } else { //为应用程序进程启动Binder线程池 RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion,parsedArgs.remainingArgs); } } else { String className; try { //读取新进程执行的类名,在Process.start()函数中,传过来的类名为:"android.app.ActivityThread" className = parsedArgs.remainingArgs[0]; } catch (ArrayIndexOutOfBoundsException ex) { logAndPrintError(newStderr,"Missing required class name argument", null); return; } String[] mainArgs = new String[parsedArgs.remainingArgs.length - 1]; System.arraycopy(parsedArgs.remainingArgs, 1,mainArgs, 0, mainArgs.length); 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(); } //加载并执行"android.app.ActivityThread"类 try { ZygoteInit.invokeStaticMain(cloader, className, mainArgs); } catch (RuntimeException ex) { logAndPrintError(newStderr, "Error starting.", ex); } } } }

由于应用程序启动参数中已经设置了"--runtime-init"标志位,因此新创建的应用程序进程将调用RuntimeInit.zygoteInit()函数来初始化运行时库,为应用程序启动Binder线程池,完成这些准备工作后,调用应用程序进程的入口函数ActivityThread.main()为应用程序进程创建消息循环。

接下来我们就看一下RuntimeInit.zygoteInit()

此函数在/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java中

public static final void zygoteInit(int targetSdkVersion, String[] argv)     throws ZygoteInit.MethodAndArgsCaller {   if (DEBUG) Slog.d(TAG, "RuntimeInit: Starting application from zygote");   //重定向Log输出流   redirectLogStreams();   //初始化运行环境   commonInit();   //启动Binder线程池   nativeZygoteInit();   //调用程序入口函数   applicationInit(targetSdkVersion, argv); } 

接下来我们看一下applicationInit()

private static void applicationInit(int targetSdkVersion, String[] argv)     throws ZygoteInit.MethodAndArgsCaller {   // If the application calls System.exit(), terminate the process   // immediately without running any shutdown hooks. It is not possible to   // shutdown an Android application gracefully. Among other things, the   // Android runtime shutdown hooks close the Binder driver, which can cause   // leftover running threads to crash before the process actually exits.   nativeSetExitWithoutCleanup(true);    // We want to be fairly aggressive about heap utilization, to avoid   // holding on to a lot of memory that isn't needed.   VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);   VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);    final Arguments args;   try {     args = new Arguments(argv);   } catch (IllegalArgumentException ex) {     Slog.e(TAG, ex.getMessage());     // let the process exit     return;   }    // Remaining arguments are passed to the start class's static main   invokeStaticMain(args.startClass, args.startArgs);  } 

在这里我们重点要看一下invokeStaticMain()
通过调用invokeStaticMain来调用args.startClass这个类的main()方法。

说明开启又一个新世界。

在之前提过zygote的socket的客户端可以是AMS,下一节我们分析如何开启一个Activity。