Android5.0：zygote

zygote本身是一个Linux的Native应用程序，当init进程启动完毕之后，通过init.rc文件启动zygote并修改进程名字为zygote(frameworks/base/cmds/app_process/app_main.cpp文件)。它是一个deamon进程，启动VM，加载class和resource等。之后唯一的任务就是监听socket(/dev/socket/zygote这个是用来监听的socket)并启动application，所有APP的父进程皆为zygote进程。
zygote从”/dev/socket/zygote”监听到APP启动的请求之后，最终会fork()一个子进程。我们知道fork()会完全复制父进程(clone)到另外的一个用户空间。当zygote进行fork之后，还需要创建新的Dalvik VM，还需要preload那些APP需要的class和resource。看起来像是zygote每次启动一个APP的时候都要重新复制整块的内存并重新加载class和resouce，但其实不然，这是因为Linux内核实现的Copy-On-Write(COW)。有Copy-On-Write，意味着在fork复制内存操作中，没有内存是会被马上拷贝的。而是在进程在改写这段内存的时候，kernel会中断这种写操作并先做之前没有做的复制操作。在zygote进行preload的class和resource都是只读的文件，所以在启动APP和运行APP的过程中，没有class和resource是会被复制到另外的内存的，而是所有的APP都在用同一份class和resource，也就是zygote启动的时候加载的那些。

zygote进程的启动

1.设置init.xx.rc启动运行相关service

//system/core/rootdir/init.zygotexx.rc //xx是64或者32，看平台
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    socket zygote stream 660 root system 
    //设置zygote相关的socket名字，权限等。会生成/dev/socket/zygote节点，权限如下：
    //srw-rw---- root     system      2012-01-28 13:39 zygote
    onrestart write /sys/android_power/request_state wake //??
    onrestart write /sys/power/state on //??
    onrestart restart media
    onrestart restart netd
    onrestart restart loc_launcher

2.init进程读到上面的service之后，会跑到/frameworks/base/cmds/app_process/app_main.cpp文件的main函数，并传入参数。main函数主要做以下几件事情
1)修改当前进程名字为zygote

if (!niceName.isEmpty()) {
    runtime.setArgv0(niceName.string());
    set_process_name(niceName.string());
}
//通过这个最终用prctl()系统调用修改当前进程的名字为zygo

2)调用AppRuntime.start函数!! 下面会继续分析AppRuntime.start函数

AppRuntime.start()函数

AppRuntime.start函数做如下一些事情
1) startVm()初始化DVM

2) startReg()注册JNI函数

3)

char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");

env->CallStaticVoidMethod(startClass, startMeth, strArray)
//加载"com.android.internal.os.ZygoteInit"类并调用其main函数。
//第一个java函数调用开始了~~

zygoteinit.java的main()函数

ZygoteInit.main函数主要做以下几件事情
1.调用registerZygoteSocket函数创建了一个socket接口，用来和ActivityManagerService通讯

boolean startSystemServer = false;
String socketName = "zygote";
registerZygoteSocket(socketName);

registerZygoteSocket()函数如下：

private static void registerZygoteSocket(String socketName) {
    if (sServerSocket == null) {
        int fileDesc;
        final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
        try {
            String env = System.getenv(fullSocketName);
            fileDesc = Integer.parseInt(env);
        } catch (RuntimeException ex) {
            throw new RuntimeException(fullSocketName + " unset or invalid", ex);
        }

        try {
            sServerSocket = new LocalServerSocket(
                createFileDescriptor(fileDesc));
        } catch (IOException ex) {
            throw new RuntimeException(
                "Error binding to local socket '" + fileDesc + "'", ex);
        }
    }
}

可以看到registerZygoteSocket()函数通过叫fullSocketName的环境变量得到env并转换为文件描述符。
这个环境变量的名字可以从上面的函数中知道是”ANDROID_SOCKET_zygote”。这个环境变量是在哪里设置的呢？
我们知道，系统启动脚本文件system/core/rootdir/init.rc是由init进程来解释执行的，而init进程的源代码位于system/core/init目录中，在init.c文件中，是由service_start函数来解释init.rc文件中的service命令的。每一个service命令都会促使init进程调用fork函数来创建一个新的进程，在新的进程里面，会分析里面的socket选项，对于每一个socket选项，都会通过create_socket函数来在/dev/socket目录下创建一个文件，在这个场景中，这个文件便是zygote了，然后得到的文件描述符通过publish_socket函数写入到环境变量中去。publish_socke()函数中可以看到是如何设置环境变量的。

static void publish_socket(const char *name, int fd)
{
    char key[64] = ANDROID_SOCKET_ENV_PREFIX;
    char val[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);

    /* make sure we don't close-on-exec */
    fcntl(fd, F_SETFD, 0);
}

因此，这里就把上面得到的文件描述符写入到以”ANDROID_SOCKET_zygote”为key值的环境变量中。又因为上面的ZygoteInit.registerZygoteSocket函数与这里创建socket文件的create_socket函数是运行在同一个进程中，因此，上面的ZygoteInit.registerZygoteSocket函数可以直接使用这个文件描述符来创建一个Java层的LocalServerSocket对象。如果其它进程也需要打开这个/dev/socket/zygote文件来和Zygote进程进行通信，那就必须要通过文件名来连接这个LocalServerSocket了

2.预加载

static void preload() {  
        Log.d(TAG, "begin preload");  
        preloadClasses();  
        preloadResources();  
        preloadOpenGL();  
        preloadSharedLibraries();  
        // Ask the WebViewFactory to do any initialization that must run in the zygote process,  
        // for memory sharing purposes.  
        WebViewFactory.prepareWebViewInZygote();  
        Log.d(TAG, "end preload");  
    }  

3.调用startSystemServer函数来启动SystemServer组件

private static boolean startSystemServer(String abiList, String socketName)
            throws MethodAndArgsCaller, RuntimeException {
    long capabilities = posixCapabilitiesAsBits(
            OsConstants.CAP_BLOCK_SUSPEND,
            OsConstants.CAP_KILL,
            OsConstants.CAP_NET_ADMIN,
            OsConstants.CAP_NET_BIND_SERVICE,
            OsConstants.CAP_NET_BROADCAST,
            OsConstants.CAP_NET_RAW,
            OsConstants.CAP_SYS_MODULE,
            OsConstants.CAP_SYS_NICE,
            OsConstants.CAP_SYS_RESOURCE,
            OsConstants.CAP_SYS_TIME,
            OsConstants.CAP_SYS_TTY_CONFIG
        );

    /* Hardcoded command line to start the system server */
    String args[] = {//SystemServer进程的uid,gid等等，，很多参数设置，需要仔细看看
        "--setuid=1000",
        "--setgid=1000",
        //WTL_EDM_START
        // "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1032,3001,3002,3003,3006,3007",
            //Adds system to net_raw and net_admin (3004, 3005)
            //groups, so that system can use iptables.

"-- setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3004,3005,3006,3007",
    //WTL_EDM_END
    "--capabilities=" + capabilities + "," + capabilities,
    "--runtime-init",
    "--nice-name=system_server",
    "com.android.server.SystemServer",
    };

    ZygoteConnection.Arguments parsedArgs = null;
    int pid;

    try {
        //按照上面的参数赋值给parsedArgs
        parsedArgs = new ZygoteConnection.Arguments(args);
        ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

        //fork出来一个SystemServer进程
        /* 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);
        }
        //SystemServer进程跑到这里，开始跑handleSystemServerProcess()。
        handleSystemServerProcess(parsedArgs);
    }
    return true;
}

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 */  
    }  

这里重点是RuntimeInit.zygoteInit()函数

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);
}

这个函数都是做一些初始化工作，其中nativeZygoteInit最终会调用到app_main.cpp中的onZygoteInit。

virtual void onZygoteInit()
{
    // Re-enable tracing now that we're no longer in Zygote.
    atrace_set_tracing_enabled(true);

    sp<ProcessState> proc = ProcessState::self();
    ALOGV("App process: starting thread pool.\n");
    proc->startThreadPool();
}

applicationInit函数中的invokeStaticMain(args.startClass, args.startArgs, classLoader)最终会调用SystemServer.java中的main函数。ZygoteInit.java的startSystemServer()函数中，args参数的最后一个就是 “com.android.server.SystemServer”，所以最后调用的就是这个库的main函数。

/**
 * The main entry point from zygote.
 * */
public static void main(String[] args) {
    new SystemServer().run();
}

这里看到SystemServer启动，但具体内容很多，需要后面再进行分析。

4.调用runSelectLoopMode函数进入一个无限循环在前面创建的socket接口上等待ActivityManagerService请求创建新的应用程序进程。

runSelectLoop()->ZygoteConnection.runOnce()函数负责接收command并启动APP

/*runSelectLoop()函数中，GC_LOOP_COUNT表示跑起来几个APP之后调用一次gc()清理内存。
如果内存较小，可以适当调整这个值？*/

从这里可以再进一步看看ActivityManagerService是怎么组织参数发给zygote来启动一个参数的。
这里也涉及到安全等，需要仔细检查一下。

//安全相关的
applyUidSecurityPolicy(parsedArgs, peer, peerSecurityContext);
applyRlimitSecurityPolicy(parsedArgs, peer, peerSecurityContext);
applyInvokeWithSecurityPolicy(parsedArgs, peer, peerSecurityContext);
applyseInfoSecurityPolicy(parsedArgs, peer, peerSecurityContext);
//需要设置的uid,gid等，，
pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                    parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, 
                    parsedArgs.seInfo,parsedArgs.category, parsedArgs.accessInfo, 
                    parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                    parsedArgs.appDataDir);

至此，zygote进程的启动分析就结束了，它会一直循环在这里，等待其他进程请求它孵化出新的进程。