zygote启动流程

//通过cmd命令，来fork新进程执行类中的main()方法： app_process [可选参数] 命令所在路径 启动的类名 [可选参数]








init.zygote32.rc(system/core/rootdir)
service zygote /system/bin/app_process(可执行程序所在的目录) -Xzygote(虚拟机参数，在启动虚拟机时传递给虚拟机) /system/bin --zygote(表示启动zygote进程) --start-system-server(表示启动system_Server)
    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
    writepid /dev/cpuset/foreground/tasks
//app_process源码位于App_main.cpp中
int main(int argc, char* const argv[])
{
    //prctl()方法是一个系统调用指令，根据第一个参数来确定具体的操作及返回值。
//prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0)用来防止动态的改变权限。跟SELinux有关。
//在老版本的内核中，不会解析PR_SET_NO_NEW_PRIVS，这时会返回EINVAL
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
        if (errno != EINVAL) {
            LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));
            return 12;
        }
    }



//参数为"-Xzygote /system/bin --zygote --start-system-server"
//argc为5
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    
    argc--;
    argv++;//忽略第一个参数

    int i;
    for (i = 0; i < argc; i++) {
        if (argv[i][0] != '-') {
            break;
        }
        if (argv[i][1] == '-' && argv[i][2] == 0) {
            ++i; 
            break;
        }
//将argv[i]加到runtime的mOption列表中
        runtime.addOption(strdup(argv[i]));
    }
    //参数解析
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;//String8是Android的变量类型，表示一个单字节字符串
    String8 className;
    ++i; 
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
//对于64位系统，系统nice_name名称为zygote64,32位系统为zygote
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg, "--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg, "--application") == 0) {
            application = true;
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg, "--", 2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }


    Vector<String8> args;
    if (!className.isEmpty()) {
//运行application或tool程序
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {//会进入这个分支
        //进入zygote模式，创建/data/dalvik-cache路径
        maybeCreateDalvikCache();
        if (startSystemServer) {
            args.add(String8("start-system-server"));
        }
        char prop[PROP_VALUE_MAX];
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
            LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
                ABI_LIST_PROPERTY);
            return 11;
        }
        String8 abiFlag("--abi-list=");
        abiFlag.append(prop);
        args.add(abiFlag);
        for (; i < argc; ++i) {
            args.add(String8(argv[i]));
        }
    }
//设置进程名
    if (!niceName.isEmpty()) {
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }


    if (zygote) {
//启动AppRuntime
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
//没有指定类名或zygote，则报参数错误
        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;
    }
}


总结：主要是完成一些参数的解析，然后启动AppRuntime


//----------------------------------------------------------------------------------------------------------------
AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{

    static const String8 startSystemServer("start-system-server");
//循环对传入的参数args进行匹配，如果传入的参数有startSystemServer,则进行一个日志的记录
    for (size_t i = 0; i < options.size(); ++i) {
        if (options[i] == startSystemServer) {
           const int LOG_BOOT_PROGRESS_START = 3000;
           LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
        }
    }
//完成环境变量ANDROID_ROOT的设置，通过调用getenv()和setenv()进行获取和设置
    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            LOG_FATAL("No root directory specified, and /android does not exist.");
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);
    }
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);//完成JNI接口的初始化
    JNIEnv* env;
启动虚拟机，在该方法中，定义了虚拟机的一系列参数，通过property_get()方法来进行参数的设置
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);
//注册Android方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }


    //定义参数的目的是将AndroidRuntime::start的两个参数传到ZygoteInit的main()方法中
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;


    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
//strArray存储的是关于虚拟机的参数
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
//className的值为com.android.internal.os.ZygoteInit
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);
....
    if (startClass == NULL) {
        ....
    } 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 {
//启动ZygoteInit的main()方法，通过该方法进入到了java世界
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    free(slashClassName);
....
}




int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
{
    JavaVMInitArgs initArgs;
    ...
//jni检测功能，由native层调用jni函数时进行常规检测，比较弱字符串格式是否符合要求，资源是否正确解释
    bool checkJni = false;
    property_get("dalvik.vm.checkjni", propBuf, "");
    if (strcmp(propBuf, "true") == 0) {
        checkJni = true;
    } else if (strcmp(propBuf, "false") != 0) {
        property_get("ro.kernel.android.checkjni", propBuf, "");
        if (propBuf[0] == '1') {
            checkJni = true;
        }
    }
    ALOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
    if (checkJni) {
        addOption("-Xcheck:jni");
    }
...
//虚拟机产生的trace文件，主要用于分析系统问题，路径默认为/data/anr/trace.txt
    parseRuntimeOption("dalvik.vm.stack-trace-file", stackTraceFileBuf, "-Xstacktracefile:");
......
    //添加响应的handler操作
    addOption("exit", (void*) runtime_exit);
    //读取作为dex2oat compiler运行时的操作
    addOption("vfprintf", (void*) runtime_vfprintf);
    addOption("sensitiveThread", (void*) runtime_isSensitiveThread);
//对于不同的软硬件环境，调整参数以达到系统最佳的性能
    parseRuntimeOption("dalvik.vm.heapstartsize", heapstartsizeOptsBuf, "-Xms", "4m");
    parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");
    parseRuntimeOption("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
    parseRuntimeOption("dalvik.vm.heapminfree", heapminfreeOptsBuf, "-XX:HeapMinFree=");
    parseRuntimeOption("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
    parseRuntimeOption("dalvik.vm.heaptargetutilization",
                       heaptargetutilizationOptsBuf,
                       "-XX:HeapTargetUtilization=");
    ......


    //preload-classes文件内容是由WritPreloadedClassFile.java生成的
    if (!hasFile("/system/etc/preloaded-classes")) {
        ALOGE("Missing preloaded-classes file, /system/etc/preloaded-classes not found: %s\n",
              strerror(errno));
        return -1;
    }
.....
.....
//初始化虚拟机
    if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
        ALOGE("JNI_CreateJavaVM failed\n");
        return -1;
    }
    return 0;
}






int AndroidRuntime::startReg(JNIEnv* env)
{ //设置线程创建方法为javaCreateThreadEtc
    androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
    env->PushLocalFrame(200);
//进程JNI方法的注册
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    env->PopLocalFrame(NULL);
    return 0;
}




总结：通过参数创建虚拟机，完成JNI函数的注册


//----------------------------------------------------------------------------------------------------------------------------
ZygoteInit.java
public static void main(String argv[]) {
try {
RuntimeInit.enableDdms();//开启DDMS的功能

SamplingProfilerIntegration.start();


boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}


registerZygoteSocket(socketName);//为Zygote注册Socket
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,SystemClock.uptimeMillis());
preload();//预加载类和资源
EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,SystemClock.uptimeMillis());
SamplingProfilerIntegration.writeZygoteSnapshot();
gcAndFinalize();//GC操作
Trace.setTracingEnabled(false);
if (startSystemServer) {
startSystemServer(abiList, socketName);
}
runSelectLoop(abiList);//启动循环模式，等待客户端请求
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (RuntimeException ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}




//为Zygote注册Socket
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 {
FileDescriptor fd = new FileDescriptor();
fd.setInt$(fileDesc);//设置文件描述符
sServerSocket = new LocalServerSocket(fd);//创建Socket的本地服务端
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}


static void preload() {
preloadClasses();//预加载位于preload-classes中的类
preloadResources();//预加载资源，包含drawable和color资源
preloadOpenGL();//预加载OpenGL
preloadSharedLibraries();//预加载"android","compiler_rt","gnigraphics"
preloadTextResources();//预加载文本资源符连接
WebViewFactory.prepareWebViewInZygote();//仅用于zygote进程，用于内存共享进程
}




private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
//sServerSocket是Zygote进程的服务端
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
while (true) {
StructPollfd[] pollFds = new StructPollfd[fds.size()];
for (int i = 0; i < pollFds.length; ++i) {
pollFds[i] = new StructPollfd();
pollFds[i].fd = fds.get(i);
pollFds[i].events = (short) POLLIN;
}
try {
//处理轮洵状态，当pollFd有事件到来时则往下执行，否则阻塞在这里
Os.poll(pollFds, -1);
} catch (ErrnoException ex) {
throw new RuntimeException("poll failed", ex);
}
for (int i = pollFds.length - 1; i >= 0; --i) {
//采用I/O多路复用机制，当接收到客户端发送的连接请求，或者数据处理请求到来，则往下执行
//否则退出本次循环
if ((pollFds[i].revents & POLLIN) == 0) {
continue;
}
if (i == 0) {
//当有客户端连接请求时，创建ZygoteConnection对象，并添加到fds
ZygoteConnection newPeer = acceptCommandPeer(abiList);
peers.add(newPeer);
fds.add(newPeer.getFileDesciptor());
} else {
//i>0,表示通过socket接收来自对端的数据，并执行相应的操作
boolean done = peers.get(i).runOnce();
if (done) {
peers.remove(i);
fds.remove(i);//从fds中移除该文件描述符
}
}
}
}
}








boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {


String args[];
Arguments parsedArgs = null;
FileDescriptor[] descriptors;


try {
//读取Socket客户端发送过来的参数列表
args = readArgumentList();
descriptors = mSocket.getAncillaryFileDescriptors();
} catch (IOException ex) {
Log.w(TAG, "IOException on command socket " + ex.getMessage());
closeSocket();
return true;
}


...


int pid = -1;
FileDescriptor childPipeFd = null;
FileDescriptor serverPipeFd = null;


try {
//将Binder客户端发送过来的参数列表解析成Arguments对象格式
parsedArgs = new Arguments(args);


if (parsedArgs.abiListQuery) {
return handleAbiListQuery();
}


if (parsedArgs.permittedCapabilities != 0 || parsedArgs.effectiveCapabilities != 0) {
throw new ZygoteSecurityException("Client may not specify capabilities: " +
"permitted=0x" + Long.toHexString(parsedArgs.permittedCapabilities) +
", effective=0x" + Long.toHexString(parsedArgs.effectiveCapabilities));
}
....


pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
parsedArgs.appDataDir);
} catch (ZygoteSecurityException ex) {
....
}


try {
if (pid == 0) {
// 子进程执行
IoUtils.closeQuietly(serverPipeFd);
serverPipeFd = null;
//进入子进程流程
handleChildProc(parsedArgs, descriptors, childPipeFd, newStderr);
return true;
} else {
//父进程执行
IoUtils.closeQuietly(childPipeFd);
childPipeFd = null;
return handleParentProc(pid, descriptors, serverPipeFd, parsedArgs);
}
} finally {
IoUtils.closeQuietly(childPipeFd);
IoUtils.closeQuietly(serverPipeFd);
}
}


总结：预加载各种资源，建立客户端与服务端的Socket通道