Android 系统源码-1：Android 系统启动流程源码分析

现在我们来梳理下 Android 系统的启动过程。Android 启动过程还是比较重要的，因为在这个过程中除了要完成 Linux 系统的初始化工作还要完成 Android 的基础服务和启动界面的初始化工作。

在这篇文章中，我们不打算过多深入源码。因为 Android 中任何一个功能模块在 Framework 层都涉及大量的代码调用。过多深入源码只会让我们迷失在一层层的调用栈中。相比之下，我更倾向于只出一些核心代码，另外梳理下调用栈的流程。当我们需要深入研究这方面的内容的时候，知道去哪里找答案就够了。

1、系统启动

按下电源之后，首先加载引导程序 BootLoader 到 RAM；然后，执行引导程序 BootLoader 以把系统 OS 拉起来；接着，启动 Linux 内核；内核中启动的第一个用户进程是 init 进程，init 进程会通过解析 init.rc 来启动 zygote 服务；Zygote 又会进一步的启动 SystemServer；在 SystemServer 中，Android 会启动一系列的系统服务供用户调用。

Android 系统中 init 程序对应的 Android.mk 位于 system/core/init/Android.mk，是一种 Makefile 文件，用来向编译系统描述我们的源代码。我们可以使用 make 工具来执行该文件。所以，mk 文件就像是 Shell 脚本一样。

1.1 执行 init 程序

Linux 内核加载完成后，首先启动 init 进程。在 8.0 的源码中系统启动的第一个阶段是创建启动所需的各种目录。而在最新的源码中，这部分代码被包含在了 init_first_stage 中：

    // platform/system/core/init/init_first_stage.cpp
    int main(int argc, char** argv) {
        if (REBOOT_BOOTLOADER_ON_PANIC) {
            InstallRebootSignalHandlers();
        }
        boot_clock::time_point start_time = boot_clock::now();
        std::vector<std::pair<std::string, int>> errors;
    #define CHECKCALL(x) \
        if (x != 0) errors.emplace_back(#x " failed", errno);
        umask(0);
        CHECKCALL(clearenv());
        CHECKCALL(setenv("PATH", _PATH_DEFPATH, 1));
        // 创建目录
        CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"));
        CHECKCALL(mkdir("/dev/pts", 0755));
        CHECKCALL(mkdir("/dev/socket", 0755));
        // ...
    #undef CHECKCALL
        auto reboot_bootloader = [](const char*) { RebootSystem(ANDROID_RB_RESTART2, "bootloader"); };
        InitKernelLogging(argv, reboot_bootloader);
        // ...
        const char* path = "/system/bin/init";
        const char* args[] = {path, nullptr};
        execv(path, const_cast<char**>(args));
        return 1;
    }

在系统启动过程中会多次调用 execv()，每次调用该方法时会重新执行 main() 方法。该方法如下：

int execv(const char *progname, char *const argv[]);   //#include <unistd.h>

execv() 会停止执行当前的进程，并且以 progname 应用进程替换被停止执行的进程，进程 ID 不会改变。

然后是 init.cpp 进程的入口函数 main:

    // platform/system/core/init/init.cpp
    int main(int argc, char** argv) {
        if (!strcmp(basename(argv[0]), "ueventd")) {
            return ueventd_main(argc, argv);
        }
        if (argc > 1 && !strcmp(argv[1], "subcontext")) {
            android::base::InitLogging(argv, &android::base::KernelLogger);
            const BuiltinFunctionMap function_map;
            return SubcontextMain(argc, argv, &function_map);
        }
        if (REBOOT_BOOTLOADER_ON_PANIC) {
            // 初始化重启系统的处理信号
            InstallRebootSignalHandlers();
        }
        // ...
        property_init(); // 初始化属性服务
        // ...
        Epoll epoll; // 创建 epoll 句柄
        if (auto result = epoll.Open(); !result) {
            PLOG(FATAL) << result.error();
        }

        InstallSignalFdHandler(&epoll);
        // ...
        StartPropertyService(&epoll); // 启动属性服务
        // ...

        ActionManager& am = ActionManager::GetInstance();
        ServiceList& sm = ServiceList::GetInstance();

        LoadBootScripts(am, sm); // 加载启动脚本
        // ...
        // 充电模式不启动系统，否则启动系统
        std::string bootmode = GetProperty("ro.bootmode", "");
        if (bootmode == "charger") {
            am.QueueEventTrigger("charger");
        } else {
            am.QueueEventTrigger("late-init");
        }
        // ...
        return 0;
    }

这里会在 LoadBootScripts() 方法中解析 init.rc 文件。关于该文件指令的含义可以参考 AOSP 中的文档：《Android Init Language》. 完成解析相关的类是 ActionManager、Parser 和 XXParser，均位于 system/core/init 目录下面。除此之外，还有 Action 和 Service 等类。它们的作用是，各种 Parser 用来解析 rc 文件中的指令。解析出的指令会被封装成 Action 和 Service 等对象。

打开该文件我们可以看到其中包含了下面两行代码，这里使用了占位符，也就是说，它会根据当前的环境变量加载当前目录下对应的文件。并且，我们可以看到在 system/core/rootdir 目录下面确实存在着 init.zygote64.rc 和 init.zygote32.rc 等文件。

import /init.${
   ro.hardware}.rc
import /init.${
   ro.zygote}.rc

以 rinit.zygote64.rc 为例，它表示通知 init 进程创建名为 zygote 的进程。执行路径是 /system/bin/app_process64，

// platform/system/core/rootdir/init.zygote64.rc
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
    class main
    // ...

我们可以看出它使用了 service 指令，所以它将被解析成 Service.

注意到在 init.cpp 的 main() 方法的最后，如果非充电模式将触发 late-init. 在 rc 中配置了对 late-init 事件的监听，通过 on 来实现的。同时，它又使用 trigger 触发了其他的命令。这些命令也都是通过 on 来监听的。（当然，rc 只是一种配置文件，而实际的逻辑是被解析之后在程序中完成的。）

在 late-init 事件触发的事件当中包含了 zygote-start 事件. 而 zygote-start 监听实现又根据监听条件又多种。不过，它们都会调用 start zygote 方法。这里的 start 会被映射到 builtins 类的 do_start() 方法。该方法会调用 Service 的 start() 方法。该方法主要是调用 clone 或 fork 创建子进程，然后调用 execve 执行配置的二进制文件，另外根据之前在 rc 文件中的配置，去执行这些配置。因此程序将开始执行 app_process64.

// platform/system/core/init/service.cpp
Result<Success> Service::Start() {
    // ...
    pid_t pid = -1;
    if (namespace_flags_) {
        pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
    } else {
        pid = fork();
    }

    if (pid == 0) {
        umask(077);
        // ...
        // 内部调用 execv() 来执行
        if (!ExpandArgsAndExecv(args_, sigstop_)) {
            PLOG(ERROR) << "cannot execve('" << args_[0] << "')";
        }
        _exit(127);
    }
    // ...
    return Success();
}

映射关系参考源码：system/core/init/builtins.cpp
关于 rc 文件的命令的解析，可以参考《Android 8.0 系统启动流程之init.rc解析与service流程(七)》

上述 rc 文件的 /system/bin/app_process64 对应的 mk 文件位于 /base/cmds/app_process/Android.mk 目录下面。从该文件中我们可以看出，不论 app_process、app_process32 还是 app_process64，对应的源文件都是 app_main.cpp. 于是程序将进入 app_main.cpp 的 main() 方法。

进入 main() 方法之后先要进行指令的参数的解析，

// platform/frameworks/base/cmds/app_process/app_main.cpp
int main(int argc, char* const argv[])
{
    // ...
    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 (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    } else {
        app_usage();
    }
}

我们从之前的 rc 文件中可以看出，参数为 --zygote，因此将调用 ZygoteInit 的 main() 方法继续执行。这里的 runtime 是 AndroidRuntime，这里的 start() 方法是一种 JNI 调用。这里将会调用 Java 中的静态 main() 方法继续执行。 这种调用方式还是比较重要的，我们经常在 Java 中调用 C++ 的方法，而这里是在 C++ 中调用 Java 的方法。它的源码位于 base\core\jni\AndroidRuntime.cpp.

// platform/frameworks/base/core/jni/AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    // ...

    // 获取ANDROID_ROOT环境变量
    const char* rootDir = getenv("ANDROID_ROOT");
    if (rootDir == NULL) {
        rootDir = "/system";
        if (!hasDir("/system")) {
            return;
        }
        setenv("ANDROID_ROOT", rootDir, 1);
    }

    // 启动虚拟机
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
    onVmCreated(env);

    // ... 解析 main 函数以在下面进行触发

    // 启动线程，当前线程将会变成虚拟机的主线程，并且直到虚拟机退出的时候才结束。
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
        }
    }
    // ...
}

在上面的方法中，我们可以看出启动虚拟机的时候需要调用 startVM() 方法来启动。当虚拟机启动完成之后使用句柄函数 env 来执行 ZygoteInit 的静态 main() 方法。

1.2 启动 Zygote

根据上面的分析，系统已经启动了虚拟机。并且在虚拟机启动完成之后，程序进入了 ZygoteInit 中 main() 方法中，

    // platform/framework/base/core/java/com/android/internal/os/ZygoteInit.java
    public static void main(String argv[]) {
   
        // ...
        try {
   
            // ...
            boolean startSystemServer = false;
            String socketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            for (int i = 1; i < argv.length; i++) {
   
                if (