Android FrameWork - 開機啓動 Zygote 進程

相關源碼文件：

/system/core/rootdir/init.rc
/frameworks/base/cmds/app_process/App_main.cpp
/frameworks/base/core/jni/AndroidRuntime.cpp
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
/frameworks/base/core/java/com/android/internal/os/ZygoteConnection.java

Zygote 進程是由 init 進程通過解析 init.rc 文件而創建的。

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-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

對應找到 /frameworks/base/cmds/app_process/app_main.cpp 源碼文件中的 main 方法

int main(int argc, char* const argv[])
{
    // AppRuntime 繼承 AndoirdRuntime
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    // 過濾第一個參數
    argc--;
    argv++;

    // Everything up to '--' or first non '-' arg goes to the vm.
    //
    // The first argument after the VM args is the "parent dir", which
    // is currently unused.
    //
    // After the parent dir, we expect one or more the following internal
    // arguments :
    //
    // --zygote : Start in zygote mode
    // --start-system-server : Start the system server.
    // --application : Start in application (stand alone, non zygote) mode.
    // --nice-name : The nice name for this process.
    //
    // For non zygote starts, these arguments will be followed by
    // the main class name. All remaining arguments are passed to
    // the main method of this class.
    //
    // For zygote starts, all remaining arguments are passed to the zygote.
    // main function.
    //
    // Note that we must copy argument string values since we will rewrite the
    // entire argument block when we apply the nice name to argv0.
    // Parse runtime arguments.  Stop at first unrecognized option.
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;

    ++i;  // Skip unused "parent dir" argument.
    // 解析參數
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            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;
        }
    }

    ...
    //設置進程名
    if (!niceName.isEmpty()) {
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    }
    // 如果 zygote ，AndroidRuntime 執行 com.android.internal.os.ZygoteInit 
    // 看上面解析的腳本參數執行的是這裏。
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } 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;
    }
}

上面首先是解析參數，然後來到 /frameworks/base/core/jni/AndroidRuntime.cpp 中的 start 方法：

/*
 * Start the Android runtime.  This involves starting the virtual machine
 * and calling the "static void main(String[] args)" method in the class
 * named by "className".
 *
 * Passes the main function two arguments, the class name and the specified
 * options string.
 */
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ... 
    // 創建一個虛擬機的實例
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    // JNI 方法註冊
    /*
     * 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;

    // strArray= new String[options.size() + 1];
    stringClass = env->FindClass("java/lang/String");
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    // strArray[0] = "com.android.internal.os.ZygoteInit"
    classNameStr = env->NewStringUTF(className);
    env->SetObjectArrayElement(strArray, 0, classNameStr);

    // strArray[1] = "start-system-server"；
    // strArray[2] = "--abi-list=系統響應的cpu架構類型"；
    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
    }

    // slashClassName = "com/android/internal/os/ZygoteInit"
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        // 獲取 ZygoteInit.java 的 main 方法
        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.java 的 main 方法，從 Native 世界進入 Java 世界
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
        }
    }
    ...
}

Java 代碼是跑在 Java 虛擬機上的，而 Java 與 native 通信採用的是 JNI ，從這裏我們就開始進入 Java 世界：

public static void main(String argv[]) {
    try {
        // 解析參數
        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]);
            }
        }
        ...
        // 爲 Zygote 註冊 socket 用於通信
        registerZygoteSocket(socketName);
        // 預加載類和資源
        preload(); 
        // 啓動 system_server
        if (startSystemServer) {
            startSystemServer(abiList, socketName);
        }
        // 進入循環模式，等待孵化進程
        runSelectLoop(abiList); 
        closeServerSocket();
    } catch (MethodAndArgsCaller caller) {
        caller.run();
    } catch (RuntimeException ex) {
        closeServerSocket();
        throw ex;
    }
}

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) {
            ...
        }

        try {
            FileDescriptor fd = new FileDescriptor();
            // 設置文件描述符
            fd.setInt$(fileDesc);
            // 創建 Socket 的本地服務端
            sServerSocket = new LocalServerSocket(fd); 
        } catch (IOException ex) {
            ...
        }
    }
}

static void preload() {
    // 預加載位於 /system/etc/preloaded-classes 文件中的類
    preloadClasses();

    // 預加載資源，包含 drawable 和 color 資源
    preloadResources();

    // 預加載 OpenGL
    preloadOpenGL();

    // 通過 System.loadLibrary() 方法，
    // 預加載 "android", "compiler_rt", "jnigraphics" 這3個共享庫
    preloadSharedLibraries();

    // 預加載 文本連接符資源
    preloadTextResources();

    // 僅用於 zygote 進程，用於內存共享的進程
    WebViewFactory.prepareWebViewInZygote();
}

private static boolean startSystemServer(String abiList, String socketName) throws MethodAndArgsCaller, RuntimeException {
    ...
    // 設置一些參數 
    String args[] = {
        "--setuid=1000",
        "--setgid=1000",
        "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1032,3001,3002,3003,3006,3007",
        "--capabilities=" + capabilities + "," + capabilities,
        "--nice-name=system_server",
        "--runtime-args",
        "com.android.server.SystemServer",
    };

    ZygoteConnection.Arguments parsedArgs = null;
    int pid;
    try {
        ...
        // fork 創建 system_server 進程，後面會具體分析
        pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,
                parsedArgs.debugFlags,
                null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    //  pid == 0 代表子進程，也就是 system_server 進程
    if (pid == 0) {
        // 執行初始化 system_server 進程
        handleSystemServerProcess(parsedArgs);
    }
    return true;
}

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
    // sServerSocket 是 registerZygoteSocket 中創建的，即 zygote 進程。保存到 fds[0]
    fds.add(sServerSocket.getFileDescriptor());
    peers.add(null);

    while (true) {
        // 給 pollFds 設置參數，fds.size 是 1 ，也就是說 pollFds 裏面只有 sServerSocket.getFileDescriptor() 
        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 {
            // 處理輪詢狀態，當 pollFds 有事件到來則往下執行，否則阻塞在這裏
            Os.poll(pollFds, -1);
        } catch (ErrnoException ex) {
            ...
        }
        
        for (int i = pollFds.length - 1; i >= 0; --i) {
            if (i == 0) {
                // 即fds[0]，代表的是 sServerSocket，則意味着有客戶端連接請求；
                // 則創建 ZygoteConnection 對象,並添加到 fds。
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                //添加到 fds.
                fds.add(newPeer.getFileDesciptor()); 
            } else {
                // i>0，則代表通過 socket 接收來自對端的數據，並執行相應操作
                boolean done = peers.get(i).runOnce();
                if (done) {
                    peers.remove(i);
                    // 處理完則從fds中移除該文件描述符
                    fds.remove(i); 
                }
            }
        }
    }
}

boolean runOnce() throws ZygoteInit.MethodAndArgsCaller {
    String args[];
    Arguments parsedArgs = null;
    FileDescriptor[] descriptors;

    try {
        // 讀取 socket 客戶端發送過來的參數列表
        args = readArgumentList();
        descriptors = mSocket.getAncillaryFileDescriptors();
    } catch (IOException ex) {
        ...
        return true;
    }
    ...

    try {
        // 將 binder 客戶端傳遞過來的參數，解析成 Arguments 對象格式
        parsedArgs = new Arguments(args);
        ...
        // fork 創建一個新的進程
        pid = Zygote.forkAndSpecialize(parsedArgs.uid, parsedArgs.gid, parsedArgs.gids,
                parsedArgs.debugFlags, rlimits, parsedArgs.mountExternal, parsedArgs.seInfo,
                parsedArgs.niceName, fdsToClose, parsedArgs.instructionSet,
                parsedArgs.appDataDir);
    } catch (Exception e) {
        ...
    }

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

相信有很多哥們跟我有一樣的感受，剛開始部分代碼看起來晦澀難懂。其實剛開始很多地方沒必要去死摳，我們先了解整個流程，後面具體細節再慢慢啃。最後再來總結一下：Zygote 進程是由 init 進程解析 init.rc 腳本創建的，其具體的執行源碼是在 App_main.main 方法，首先會創建一個虛擬機實例，然後註冊 JNI 方法，最後通過 JNI 調用進入 Java 世界來到 ZygoteInit.main 方法。在 Java 世界中我們會爲 Zygote 註冊 socket 用於進程間通信，預加載一些通用的類和資源，啓動 system_server 進程，循環等待孵化創建新的進程。

至於怎麼啓動的 system_server 進程，如何孵化新的進程，我們到後面再去具體分析，目前我們只需知道 zygote 具體幹了些什麼就好。最後我們不妨思考一個問題：Android 爲什麼要用 zygote 來孵化進程？

Android FrameWork - 開機啓動 Zygote 進程

保持獨立思考的 2022

電量優化 - Hook 系統服務

來到微信的2021

iOS 學習之旅 - OC 篇

自己來動手實現 Native Hook

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結