深入淺出Android系統啓動流程

轉載請標明出處:【顧林海的博客】

init進程啓動過程

init進程概述

       Android系統基於Linux，init進程是Android系統中用戶空間的第一個進程，進程號爲1，init源代碼在system/core/init目錄下。既然init進程是Android系統用戶空間的第一個進程，因此擔負着非常重要的責任，主要負責以下兩件事：

1. 解析配置init.rc，然後啓動系統各種native進程，比如Zygote進程、SurfaceFlinger進程以及media進程等。
2. 初始化並啓動屬性服務。

init進程的入口函數

init的入口函數是main，代碼如下所示：

//路徑：/system/core/init/init.cpp
int main(int argc, char** argv) {
    //註釋1
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }
    //註釋2
    if (!strcmp(basename(argv[0]), "watchdogd")) {
        return watchdogd_main(argc, argv);
    }
    //註釋3
    if (REBOOT_BOOTLOADER_ON_PANIC) {
        install_reboot_signal_handlers();
    }
    
    ...
}

       註釋1處判斷當前進程是不是ueventd。init進程創建子進程ueventd，並將創建設備節點文件的工作託付給ueventd。ueventd主要是負責設備節點的創建、權限設定等一系列工作。服務通過使用uevent，監控驅動發送的消息，做進一步處理。

ueventd通過兩種方式創建設備節點文件。

1. “冷插拔”（Cold Plug），即以預先定義的設備信息爲基礎，當ueventd啓動後，統一創建設備節點文件。這一類設備節點文件也被稱爲靜態節點文件。
2. “熱插拔”（Hot Plug），即在系統運行中，當有設備插入USB端口時，ueventd就會接收到這一事件，爲插入的設備動態創建設備節點文件。這一類設備節點文件也被稱爲動態節點文件。

       註釋2處判斷當前進程是不是watchdogd。Android系統在長時間的運行下會面臨各種軟硬件的問題，爲了解決這個問題，Android開發了WatchDog類作爲軟件看門狗來監控SystemServer中的線程，一旦發現問題，WatchDog會殺死SystemServer進程，SystemServer的父進程Zygote接收到SystemServer的死亡信號後，會殺死自己。Zygote進程死亡的信號傳遞到init進程後，init進程會殺死Zygote進程所有的子進程並重啓Zygote。

       註釋3處判斷是否緊急重啓，如果是緊急重啓，就安裝對應的消息處理器。

//路徑：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    //註釋1
    add_environment("PATH", _PATH_DEFPATH);
    //註釋2
    bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);

    if (is_first_stage) {
        // 用於記錄啓動時間
        boot_clock::time_point start_time = boot_clock::now();
        // 清除屏蔽字(file mode creation mask)，保證新建的目錄的訪問權限不受屏蔽字影響
        umask(0);
        // 掛載tmpfs文件系統
        mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
        mkdir("/dev/pts", 0755);
        mkdir("/dev/socket", 0755);
        // 掛載devpts文件系統
        mount("devpts", "/dev/pts", "devpts", 0, NULL);
        #define MAKE_STR(x) __STRING(x)
        // 掛載proc文件系統
        mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
        //8.0新增, 收緊了cmdline目錄的權限
        chmod("/proc/cmdline", 0440);
        // 8.0新增，增加了個用戶組
        gid_t groups[] = { AID_READPROC };
        setgroups(arraysize(groups), groups);
        // 掛載sysfs文件系統
        mount("sysfs", "/sys", "sysfs", 0, NULL);
        // 8.0新增
        mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL)
        // 提前創建了kmsg設備節點文件，用於輸出log信息
        mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
        mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
        mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
        ...
    }
    ...
}

       註釋1處添加環境變量。註釋2處獲取本次啓動是否是系統啓動的第一階段，如果是第一階段，進入下面的if語句中，創建並掛載相關的文件系統。

以上創建並掛載的五類文件系統分別如下所示：

• tmpfs：一種虛擬內存文件系統，它會將所有的文件存儲在虛擬內存中，如果你將tmpfs文件系統卸載後，那麼其下的所有的內容將不復存在。tmpfs既可以使用RAM，也可以使用交換分區，會根據你的實際需要而改變大小。tmpfs的速度非常驚人，畢竟它是駐留在RAM中的，即使用了交換分區，性能仍然非常卓越。由於tmpfs是駐留在RAM的，因此它的內容是不持久的。斷電後，tmpfs的內容就消失了，這也是被稱作tmpfs的根本原因。

• devpts：爲僞終端提供了一個標準接口，它的標準掛接點是/dev/ pts。只要pty的主複合設備/dev/ptmx被打開，就會在/dev/pts下動態的創建一個新的pty設備文件。

• proc：一個非常重要的虛擬文件系統，它可以看作是內核內部數據結構的接口，通過它我們可以獲得系統的信息，同時也能夠在運行時修改特定的內核參數。

• sysfs：與proc文件系統類似，也是一個不佔有任何磁盤空間的虛擬文件系統。它通常被掛接在/sys目錄下。sysfs文件系統是Linux2.6內核引入的，它把連接在系統上的設備和總線組織成爲一個分級的文件，使得它們可以在用戶空間存取。

• selinuxfs：用於支持SELinux的文件系統，SELinux提供了一套規則來編寫安全策略文件，這套規則被稱之爲 SELinux Policy 語言。

//路徑：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
        //重定向輸入輸出/內核Log系統
        InitKernelLogging(argv);
        LOG(INFO) << "init first stage started!";
        //掛在一些分區設備
        if (!DoFirstStageMount()) {
            LOG(ERROR) << "Failed to mount required partitions early ...";
            panic();
        }
        //註釋1
        SetInitAvbVersionInRecovery();
        //註釋2
        selinux_initialize(true);
        ...
    }
    ...
}

       註釋1處初始化安全框架AVB（Android Verified Boot），AVB主要用於防止系統文件本身被篡改，還包含了防止系統回滾的功能，以免有人試圖回滾系統並利用以前的漏洞。註釋2處調用selinux_initialize啓動SELinux。

//路徑：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
    }
    ...
    //註釋1
    property_init();  
    ...
    //註釋2
    signal_handler_init();
    ...
    //註釋3
    start_property_service();
    ...
}

       註釋1處通過property_init函數對屬性服務進行初始化，註釋3通過start_property_service函數啓動屬性服務。註釋2處signal_handler_init設置子進程退出的信號處理函數，當子進程異常退出的時候，init進程會去捕獲異常信息，當它捕獲到這些異常信息之後，就會調用該函數設置的相應的捕獲函數來處理。比如init進程的子進程Zygote死之後，init進程捕獲到這些異常信息，就會調用handle_signal()函數去重啓Zygote進程。

//路徑：/system/core/init/init.cpp
int main(int argc, char** argv) {
    ...
    if (is_first_stage) {
        ...
    }
    ...
     if (bootscript.empty()) {
        //註釋1
        parser.ParseConfig("/init.rc");
        ...
    } else {
        ...
    }
    ...
    while (true) {
        ...
        ServiceManager::GetInstance().IsWaitingForExec())) {
            //註釋2
            am.ExecuteOneCommand();
        }
        if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
            //註釋3
            restart_processes();
            ...
        }
        ...
    }    
    return 0;
}

       註釋1處解析init.rc配置文件，在註釋2處執行子進程對應的命令，也就是執行init.rc文件裏配置的命令。在註釋3處重啓死掉的service。

解析init.rc

       在init.rc中使用的語言稱爲Android Init Language，翻譯過來就是“Android初始化語言”，init語言共有五種類型的表達式，分別如下所示：

• Action：Action中包含了一系列的Command。
• Command：init語言中的命令。
• Service：由init進程啓動的服務。
• Option：對服務的配置選項。
• Import：引入其他配置文件。

Action表達式的語法如下所示：

on <trigger> [&& <trigger>]*
    <command>
    <command>
    <command>

       這裏的trigger是Action執行的觸發器，當觸發器條件滿足時，command會被執行。觸發器有如下兩類：

• 事件觸發器：當指定的事件發生時觸發。事件可能由“trigger”命令發出，也可能是init進程通過QueueEventTrigger()函數發出。
• 屬性觸發器：當指定的屬性滿足某個值時觸發。

Action中的Command是init語言定義的命令，所有支持的命令如下表：

命令	參數格式	說明
bootchart_init	-	啓動bootchart
chmod	octal-mode path	改變文件的訪問權限
chown	owner group path	改變文件的擁有者和組
class_start	serviceclass	啓動指定類別的服務
class_stop	serviceclass	停止並“disable”指定類別的服務
class_reset	serviceclass	停止指定類別的服務，但是不“disable”它們
copy	src dst	複製文件
domainname	name	設置域名
enable	servicename	enable一個被disable的服務
exec	[seclabel[user[group]]] – command [argument]*	fork一個子進程來執行指定的命令
export	name value	導出環境變量
hostname	name	設置host名稱
ifup	iterface	使網卡在線
insmod	path	安裝指定路徑的模塊
load_all_props	-	從/system、/vendor等路徑載入屬性
load_persist_props	-	載入持久化的屬性
loglevel	level	設置內核的日誌級別
mkdir	path[mode][owner][group]	創建目錄
mount_all	fstab[path]*[–option]	掛載文件系統並且導入指定的.rc文件
mount	typedevicedir[flag]*[options]	掛載一個文件系統
powerctl	-	內部實現使用
restart	service	重啓服務
restorecon	path[path]*	設定文件的安全上下文
restorecon_recursive	path[path]*	restorecon的遞歸版本
rm	path	對於指定路徑調用unlink(2)
rmdir	path	刪除文件夾
setprop	namevalue	設置屬性值
setrlimit	resourcecurmax	指定資源的rlimit
start	service	啓動服務
stop	service	停止服務
swapon_all	fstab	在指定文件上調用fs_mgr_swapon_all
symlink	targetpath	創建符合鏈接
sysclktz	mins_west_of_gmt	指定系統時鐘基準
trigger	event	觸發一個事件
umount	path	ummount指定的文件系統
verity_load_state	-	內部實現使用
verity_update_state	mount_point	內部實現使用
wait	path[timeout]	等待某個文件存在直到超時，若存在則直接返回
write	pathcontent	寫入內容到指定文件

Service是init進程啓動的可執行程序，Service表達式的語法如下所示:

service <name> <pathname> [ <argument> ]*
    <option>
    <option>

Option是對服務的修飾，它們影響着init進程如何以及何時啓動服務。所有支持的Option入下所示：

Option	參數格式	說明
critical	-	標識爲系統關鍵服務，該服務若退出多次將導致系統重啓到recovery模式
disabled	-	不會隨着類別自動啓動，必須明確start
setenv	name value	爲啓動的進程設置環境變量
socket	nametypeperm[user[group[seclabel]]]	創建UNIX Domain Socket
user	username	在執行服務之前切換用戶
group	groupname[groupname]*	在執行服務之前切換組
seclabel	seclabel	在執行服務之前切換seclabel
oneshot	-	一次性服務，死亡後不用重啓
class	name	指定服務的類別
onrestart	-	當服務重啓時執行命令
writepid	file…	寫入子進程的pid到指定文件

import是一個關鍵字，而不是一個命令，可以在.rc文件中通過這個關鍵字來加載其他的.rc文件，它的語法如下：

import path

path可以是另一個.rc文件，也可以是一個文件夾。如果是文件夾，那麼這個文件夾下面的所有文件都會被導入，但是它不會循環加載子目錄中的文件。

啓動Zygote

init.rc文件有如下配置代碼：

...
import /init.${ro.zygote}.rc
...
on nonencrypted
    class_start main
    class_start late_start
...    

在init.rc文件的開頭使用了import類型語句來引入Zygote啓動腳本，其中ro.zygote根據不同的內容引入不同的文件，從Android 5.0開始，Android開始支持64位程序，Zygote就有了32位和64位之分，如下圖所示：

查看init.zygote64.rc的代碼如下所示：

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

       Service用於通知init進程創建名爲zygote的進程，這個進程執行程序的路徑爲/system/bin/app_process64，後面的代碼是傳遞給app_process64的參數，class main指的是Zygote的classname爲main。在解析Service類型語句時會將Service對象加入Service鏈表中。

再回過頭看init.rc配置文件：

...
import /init.${ro.zygote}.rc
...
on nonencrypted
    class_start main
    class_start late_start
...    

       class_start是一個command，對應的函數是do_class_start，用於啓動classname爲main的Service，也就是前面的Zygote，因此class_start main是用來啓動Zygote的，do_class_start函數在builtins.cpp中定義，代碼如下所示：

//路徑：/system/core/init/builtins.cpp
static int do_class_start(const std::vector<std::string>& args) {
        /* Starting a class does not start services
         * which are explicitly disabled.  They must
         * be started individually.
         */
    ServiceManager::GetInstance().
        ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
    return 0;
}

ForEachServiceInClass函數會遍歷Service鏈表，找到classname爲main的Zygote，並執行StartIfNotDisabled函數，代碼如下所示：

//路徑：/system/core/init/service.cpp
bool Service::StartIfNotDisabled() {
    if (!(flags_ & SVC_DISABLED)) {
        return Start();
    } else {
        flags_ |= SVC_DISABLED_START;
    }
    return true;
}

如果Service沒有在其對應的rc文件中設置disabled選項，就會調用Start函數，Start函數如下所示：

//路徑：/system/core/init/service.cpp
bool Service::Start() {
    ...
    pid_t pid = -1;
    if (namespace_flags_) {
        pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
    } else {
        //註釋1
        pid = fork();
    }

    if (pid == 0) {
        ...
        //註釋2
        if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
            PLOG(ERROR) << "cannot execve('" << strs[0] << "')";
        }
        ...
    }
    ...
}

       在註釋1處通過fork函數創建子進程，並返回pid，如果pid爲0說明當前代碼邏輯在子線程中運行，接着執行註釋2處的execve函數，來啓動Service子進程，進入Service的main函數中，如果Service是Zygote，執行程序的路徑是/system/bin/app_process64，對應的文件是app_main.cpp，也就是會進入app_main.cpp的main函數中。代碼如下所示：

int main(int argc, char* const argv[])
{
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            //註釋1
            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 (zygote) {
        //註釋2
        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.");
    }
}

       在註釋1處判斷執行命令時是否帶了–zygote，如果攜帶了，zygote賦值爲true，接在註釋2處判斷如果zygote爲true，就會通過runtime.start啓動com.android.internal.os.ZygoteInit。

Zygote進程啓動過程

       在Android系統中，所有的應用程序及系統服務SystemServer進程都由Zygote進程通過Linux的for()函數孵化出來的，因此我們稱Zygote是孵化器。

在前面知道了init啓動Zygote的相關操作在app_main.cpp的main函數中的，代碼如下：

int main(int argc, char* const argv[])
{
    ...
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            //註釋1
            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 (zygote) {
        //註釋2
        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.");
    }
}

main函數中通過前面的if條件判斷語句來區分當前運行在哪個進程，如果是Zygote進程，就會在註釋1處將zygote賦值爲true，同時執行註釋2處的runtime的start函數。

Zygote進程孵化子進程是通過自己的資源複製一份，來fork一個新的子進程，也就是說子進程進入這個文件的main函數，因此，這裏的main函數被調用並不只是Zygote啓動的時候調用。既然子進程啓動的時候同樣被調用，那麼怎麼區分是被Zygote進程本身調用的還是它的子進程調用的呢？這裏就通過zygote這個變量來區分，如果是Zygote進程本身，變量zygote爲true，否則就會進入到下面的else if裏，代表子進程啓動。

runtime是一個AppRuntime對象，AppRuntime類繼承AndroidRuntime類，因此前面調用的是AndroidRuntime的start函數，代碼如下所示：

//路徑：/frameworks/base/core/jni/AndroidRuntime.cpp
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;
    //啓動Java虛擬機
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    //註冊JNI方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    ...
    //註釋1
    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);
    }

    //將className中的“.”替換成“/”
    //註釋2
    char* slashClassName = toSlashClassName(className);
    //註釋3
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ...
    } else {
        //註釋4
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
           ...
        } else {
            //註釋5
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
    ...
}

AndroidRuntime的start函數主要做了以下幾件事：

• 通過startVm函數啓動Java虛擬機。
• 通過startReg函數註冊JNI方法。
• 調用com.android.internal.os.ZygoteInit類的main函數。

其中註釋1處的傳遞過來的className值是com.android.internal.os.ZygoteInit，在註釋2處將className中的“.”全部替換爲“/”，替換後的值是com/android/internal/os/ZygoteInit，在註釋3處獲取ZygoteInit類，在註釋4處獲取ZygoteInit的main方法，最後在註釋5處通過JNI調用ZygoteInit的main方法，至此我們進入Java框架層。

ZygoteInit類的main方法如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer();

        ...

        try {
            ...
            //註釋1
            zygoteServer.registerServerSocket(socketName);
            
            if (!enableLazyPreload) {
                ...
                //註釋2
                preload(bootTimingsTraceLog);
                ...
            } else {
                Zygote.resetNicePriority();
            }

            ...
            //註釋3
            if (startSystemServer) {
                startSystemServer(abiList, socketName, zygoteServer);
            }

            //註釋4
            zygoteServer.runSelectLoop(abiList);

            zygoteServer.closeServerSocket();
        } catch (Zygote.MethodAndArgsCaller caller) {
            caller.run();
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            zygoteServer.closeServerSocket();
            throw ex;
        }
    }

ZygoteInit的main方法中，註釋1處通過registerServerSocket方法創建一個Zygote的Socket接口用來和AMS通信。查看registerServerSocket方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void registerServerSocket(String socketName) {
        if (mServerSocket == null) {
            ...

            try {
                ...
                //註釋1
                mServerSocket = new LocalServerSocket(fd);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket '" + fileDesc + "'", ex);
            }
        }
    }

註釋1處創建了一個Java層的LocalServerSocket對象ServerSocket，用於等待創建新的應用程序進程請求連接。

ZygoteInit的main方法中，註釋2處通過preload方法預加載類和資源，如果系統不預加載類和資源，每次啓動一個應用程序都會去加載這些類和資源，那麼啓動應用程序的時間就會很長。

ZygoteInit的main方法中，註釋3處通過startSystemServer方法啓動SystemServer進程。查看startSystemServer方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",
        };
        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

        try {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ...
            //註釋2
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //註釋3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket();
            //註釋4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

註釋1處args數組保存的是SystemServer的啓動參數，最後封裝成Arguments對象，在註釋2處通過Zygote的forkSystemServer方法創建子進程，該方法內部會調用nativeForkSystemServer這個Native方法，nativeForkSystemServer方法最終通過fork函數創建一個子進程。在註釋3處，判斷pid是否等於0，如果等於0，說明當前的代碼運行在新創建的子進程中，最後通過註釋4處的handleSystemServerProcess方法啓動SystemServer進程。

ZygoteInit的main方法中，註釋4處調用runSlectLoop方法，通過前面創建的Socket接口，進入一個無限循環，等待覈心服務ActivityManagerService請求創建新的應用程序進程。查看runSlectLoop方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteServer.java
    void runSelectLoop(String abiList) throws Zygote.MethodAndArgsCaller {
        ...

        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 {
                Os.poll(pollFds, -1);
            } catch (ErrnoException ex) {
                throw new RuntimeException("poll failed", ex);
            }
            for (int i = pollFds.length - 1; i >= 0; --i) {
                if ((pollFds[i].revents & POLLIN) == 0) {
                    continue;
                }
                //註釋1處
                if (i == 0) {
                    ZygoteConnection newPeer = acceptCommandPeer(abiList);
                    peers.add(newPeer);
                    fds.add(newPeer.getFileDesciptor());
                } else {
                    boolean done = peers.get(i).runOnce(this);
                    if (done) {
                        peers.remove(i);
                        fds.remove(i);
                    }
                }
            }
        }
    }

在註釋1處，如果i==0，說明Zygote的Socket服務還沒準備好，接下來通過acceptCommandPeer方法得到ZygoteConnection對象，並添加到Socket連接列表peers中，同時將這個ZygoteConnection的fd添加到fd列表fds中，以便可以接收到AMS發送過來的請求。如果i!=0，說明正在等待客戶端來連接服務端的Socket，當AMS向Zygote進程發送一個創建應用程序進程的請求時，就會調用ZygoteConnection的runOnce()函數來創建應用程序進程的請求，成功創建後從Socket連接列表peers和fd列表中清除這個連接。

SystemServer進程

SystemServer進程主要用於創建系統服務，比如AMS、WMS和PMS都是由它來創建的，SystemServer進程與普通的應用程序進程運行在不同的進程裏面，應用進程調用的API，很多都是通過Binder機制調用到SystemServer進程中對應的服務上的。

在ZygoteInit的main函數中通過startSystemServer函數來啓動SystemServer進程。查看startSystemServer方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            "--setuid=1000",
            "--setgid=1000",
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
            "--capabilities=" + capabilities + "," + capabilities,
            "--nice-name=system_server",
            "--runtime-args",
            "com.android.server.SystemServer",
        };
        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

        try {
            parsedArgs = new ZygoteConnection.Arguments(args);
            ...
            //註釋2
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.debugFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
        } catch (IllegalArgumentException ex) {
            throw new RuntimeException(ex);
        }

        //註釋3
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            //註釋5
            zygoteServer.closeServerSocket();
            //註釋4
            handleSystemServerProcess(parsedArgs);
        }

        return true;
    }

這段代碼在上面已經介紹過，最後通過handleSystemServerProcess方法啓動SystemServer進程，由於SystemServer是Zygote進程fork出來的，SystemServer進程也有一份Socket，但這個Socket對SystemServer進程沒有什麼用處，因此通過註釋5處關閉這個Socket。handleSystemServerProcess方法的代碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws Zygote.MethodAndArgsCaller {

        ...
        if (systemServerClasspath != null) {
            ...
        } else {
            ...
            //註釋1
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }

    }

在註釋1處調用了ZygoteInit的zygoteInit方法，代碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        ...
        //註釋1
        ZygoteInit.nativeZygoteInit();
        //註釋2
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }

    private static final native void nativeZygoteInit();

在註釋1處調用nativeZygoteInit方法來創建Binder線程池。註釋2處調用RuntimeInit的applicationInit方法，代碼如下所示：

    //路徑：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    protected static void applicationInit(int targetSdkVersion, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        ...
        invokeStaticMain(args.startClass, args.startArgs, classLoader);
    }

applicationInit方法中調用了invokeStaticMain方法，如下所示：

    //路徑：/frameworks/base/core/java/com/android/internal/os/RuntimeInit.java
    private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws Zygote.MethodAndArgsCaller {
        Class<?> cl;

        try {
            //註釋1
            cl = Class.forName(className, true, classLoader);
        } catch (ClassNotFoundException ex) {
            ...
        }

        Method m;
        try {
            //註釋2
            m = cl.getMethod("main", new Class[] { String[].class });
        } catch (NoSuchMethodException ex) {
           ...
        } catch (SecurityException ex) {
           ...
        }

        ...
        //註釋3
        throw new Zygote.MethodAndArgsCaller(m, argv);
    }

在註釋1處通過反射獲取SystemServer類，這裏的className值是com.android.server.SystemServer，從前面ZygoteInit的startSystemServer方法中可以發現，代碼如下所示：

//路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    private static boolean startSystemServer(String abiList, String socketName, ZygoteServer zygoteServer)
            throws Zygote.MethodAndArgsCaller, RuntimeException {
        ...
        //註釋1
        String args[] = {
            ...
            "com.android.server.SystemServer",
        };
        ...
        return true;
    }

在傳入的參數中可以看到傳入的classname是com.android.server.SystemServer。

繼續回到invokeStaticMain方法中，在註釋2處獲取SystemServer的main方法，最後在註釋3處拋出一個異常對象Zgote.MethodAndArgsCaller，使用這種方式是爲了清理堆棧，這樣之後就會讓加載SystemServer類的main方法覺得自己是進程的入口。

接下來看ZygoteInit的main函數捕獲這個異常：

    //路徑：/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
        ...
        try{
        } catch (Zygote.MethodAndArgsCaller caller) {
            //註釋1
            caller.run();
        } catch (Throwable ex) {
            ...
        }
        ...
    }

註釋1處捕獲到Zygote.MethodAndArgsCaller異常後，調用它的run方法：

//路徑：/frameworks/base/core/java/com/android/internal/os/Zygote.java
 public final class Zygote { 
    ...
    public static class MethodAndArgsCaller extends Exception
            implements Runnable {
        /** method to call */
        private final Method mMethod;

        /** argument array */
        private final String[] mArgs;

        public MethodAndArgsCaller(Method method, String[] args) {
            mMethod = method;
            mArgs = args;
        }

        public void run() {
            try {
                //註釋1
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (IllegalAccessException ex) {
                throw new RuntimeException(ex);
            } catch (InvocationTargetException ex) {
                Throwable cause = ex.getCause();
                if (cause instanceof RuntimeException) {
                    throw (RuntimeException) cause;
                } else if (cause instanceof Error) {
                    throw (Error) cause;
                }
                throw new RuntimeException(ex);
            }
        }
    }
}

MethodAndArgsCaller中的成員變量mMethod，這裏指的就是SystemServer的main方法，在註釋1處通過反射執行SystemServer的main方法。

進入SystemServer的main方法中：

    //路徑：/frameworks/base/services/java/com/android/server/SystemServer.java
    public static void main(String[] args) {
        new SystemServer().run();
    }

main方法中調用了SystemServer的run方法：

//路徑：/frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
        try {

            ...
            //創建消息Looper
            Looper.prepareMainLooper();
            //加載動態庫libandroid_servers.so
            System.loadLibrary("android_servers");
            ...
            //創建系統的Context
            createSystemContext();
            //創建SystemServiceManager
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            //保存SystemServiceManager
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            //創建系統服務用的線程池
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  // InitBeforeStartServices
        }

        //開啓服務
        try {
            traceBeginAndSlog("StartServices");
            //啓動引導服務
            startBootstrapServices();
            //啓動核心服務
            startCoreServices();
            //啓動其他服務
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }
        ...
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

       run方法中最重要的就是SystemServerManager，它的作用是用來對系統的服務進行創建、啓動和生命週期管理，創建完SystemServerManager對象後，在後面的三個啓動服務方法中會通過SystemServerManager來啓動服務，startBootstrapServices方法是用於啓動引導服務，引導服務包括ActivityManagerService、PowerManagerService、PackageManagerService、DeviceIdentifiersPolicyService等服務；startCoreServices方法用於啓動核心服務，核心服務包括DropBoxManagerService、BatteryService、UsageStatsService以及WebViewUpdateService；startOtherServices方法用於啓動其他服務，其他服務包括KeyChainSystemService、TelecomLoaderService、CameraService、AlarmManagerService等服務。

在啓動其他服務中會通過ActivityManagerService的systemReady方法來啓動Launcher。

參考資料：
《Android進階解密》
《深入淺出Android源代碼》
《android init進程分析ueventd》
《Android ueventd淺析》
《ueventd.rc》
《Android7.0 Watchdog機制》
《Android8.1啓動篇（一）：深入研究init（源碼分析）》