Android系统的启动流程（一）：进入Zygote进程的初始化

最新推荐文章于 2024-05-13 13:57:17 发布

Tai_Monster

最新推荐文章于 2024-05-13 13:57:17 发布

阅读量1.9k

点赞数 4

分类专栏： Android开发笔记文章标签： android zygote java

本文链接：https://blog.csdn.net/Tai_Monster/article/details/130995768

版权

Android开发笔记专栏收录该内容

54 篇文章 13 订阅

订阅专栏

Android系统的启动流程

概要

本篇文章主要是从Android系统启动电源开始介绍到程序运行到Java框架层并且完成Zygote进程的启动为止。下面先给出一张简单的概要图，本篇文章将会从源码进行分析Android的部分启动流程，这里的源码来自于AndroidCodeSearch,截止至2023年6月7日的最新代码。
在这里插入图片描述

引入init进程

很显然Android系统从上电开始也不是一下子就会跳入init进程的，与电脑一样，需要借助引导程序来进入，我们首先来了解Android系统启动流程的前几步：

启动电源以及系统启动：从ROM中加载引导程序BootLoader进RAM中运行。
引导程序BootLoader：引导程序BootLoader将系统OS拉起来运行。
Linux内核启动：启动Linux内核，进行设置缓存等操作。完成内核设置后，它会在系统文件中寻找init.rc文件，然后启动init进程。
init进程启动：init进程做的工作比较多，主要是初始化，启动属性服务，然后启动init进程。

init进程启动过程

什么是init进程

init进程是Android系统中用户空间的第一个进程，进程号为1，是Android系统启动流程中一个关键的步骤，作为第一个进程，他被赋予了许多重要的工作流程。init进程是由多个源文件共同组成的。

init进程的入口函数

我们可以进入镜像网站查看Android系统的源码，init目录下的所有文件就组成了init进程的整体，它的main.cpp文件就是它的入口函数：

using namespace android::init;

int main(int argc, char** argv) {
#if __has_feature(address_sanitizer)
    __asan_set_error_report_callback(AsanReportCallback);
#elif __has_feature(hwaddress_sanitizer)
    __hwasan_set_error_report_callback(AsanReportCallback);
#endif
    // Boost prio which will be restored later
    setpriority(PRIO_PROCESS, 0, -20);
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }

    if (argc > 1) {
        if (!strcmp(argv[1], "subcontext")) {
            android::base::InitLogging(argv, &android::base::KernelLogger);
            const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();

            return SubcontextMain(argc, argv, &function_map);
        }

        if (!strcmp(argv[1], "selinux_setup")) {
            return SetupSelinux(argv);
        }

        if (!strcmp(argv[1], "second_stage")) {
            return SecondStageMain(argc, argv);
        }
    }

    return FirstStageMain(argc, argv);
}

这里截取了部分代码，main函数里做的就是根据传入的参数来决定进入哪个初始化函数，最终会先调用FirstStageMain，然后调用SetupSelinux，最后是调用SecondStageMain函数，完成了这整个入口函数。

这里由于篇幅原因，我们就不再深究一些细节，总的来说，init的入口函数做了许多事情，我们关注最重要的几点：

在FirstStageMain中创建和挂载启动所需的文件目录，都是系统运行时目录，顾名思义就是只有在系统运行时才存在的目录，具体代码如下：

....
 // Clear the umask.
umask(0);//清空mask，是为了赋予所有权限

CHECKCALL(clearenv());
CHECKCALL(setenv("PATH", _PATH_DEFPATH, 1));
CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"));
CHECKCALL(mkdir("/dev/pts", 0755));//mkdir是创建文件夹的指令
CHECKCALL(mkdir("/dev/socket", 0755));
CHECKCALL(mkdir("/dev/dm-user", 0755));
CHECKCALL(mount("devpts", "/dev/pts", "devpts", 0, NULL));
....

在SecondStageMain中通过调用函数来初始化属性系统：
```
....
PropertyInit();//初始化属性系统
....
```
接着继续在SecondStageMain设置信号处理函数，然后启动属性服务
```
...
InstallSignalFdHandler(&epoll);//设置信号处理函数
InstallInitNotifier(&epoll);
StartPropertyService(&property_fd);//启动属性服务
...
```
这里介绍一下什么是信号处理函数。信号处理函数主要是为了防止init进程的子进程成为僵尸进程，为了防止僵尸进程的出现，系统就会在子进程暂停和终止时发出SIGCHLD信号，而设置的信号处理函数就会接受这个信号。

然后SecondStageMain中会调用引导函数，解析init.rc配置文件

...
ActionManager& am = ActionManager::GetInstance();
ServiceList& sm = ServiceList::GetInstance();
	
LoadBootScripts(am, sm);//调用引导函数
...

可以看到这里调用了LoadBootScripts函数，实际上这个LoadBootScripts函数会解析init.rc文件：

static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
Parser parser = CreateParser(action_manager, service_list);

std::string bootscript = GetProperty("ro.boot.init_rc", "");
if (bootscript.empty()) {
    parser.ParseConfig("/system/etc/init/hw/init.rc");//1
    if (!parser.ParseConfig("/system/etc/init")) {
        late_import_paths.emplace_back("/system/etc/init");
    }
    // late_import is available only in Q and earlier release. As we don't
    // have system_ext in those versions, skip late_import for system_ext.
    parser.ParseConfig("/system_ext/etc/init");
    if (!parser.ParseConfig("/vendor/etc/init")) {
        late_import_paths.emplace_back("/vendor/etc/init");
    }
    if (!parser.ParseConfig("/odm/etc/init")) {
        late_import_paths.emplace_back("/odm/etc/init");
    }
    if (!parser.ParseConfig("/product/etc/init")) {
        late_import_paths.emplace_back("/product/etc/init");
    }
} else {
    parser.ParseConfig(bootscript);
}

}
```
这里的注释一处就调用Parse进行了对.rc文件的解析，这个init.rc文件实际上就是AIL(Android Init Language)文件，是用来初始化Android系统的语言，我们会在后面看这个文件做了什么。

其实到这里为止，我们就已经看完了大部分init进程干的事情，接下来看它的解析init.rc文件的流程。

解析init.rc

这里我们打开system/core/rootdir/init.rc文件并截取一部分：

# It is recommended to put unnecessary data/ initialization from post-fs-data
# to start-zygote in device's init.rc to unblock zygote start.
on zygote-start && property:ro.crypto.state=unencrypted
    wait_for_prop odsign.verification.done 1
    # A/B update verifier that marks a successful boot.
    exec_start update_verifier_nonencrypted
    start statsd
    start netd
    start zygote
    start zygote_secondary

on zygote-start && property:ro.crypto.state=unsupported
    wait_for_prop odsign.verification.done 1
    # A/B update verifier that marks a successful boot.
    exec_start update_verifier_nonencrypted
    start statsd
    start netd
    start zygote
    start zygote_secondary

on zygote-start && property:ro.crypto.state=encrypted && property:ro.crypto.type=file
    wait_for_prop odsign.verification.done 1
    # A/B update verifier that marks a successful boot.
    exec_start update_verifier_nonencrypted
    start statsd
    start netd
    start zygote
    start zygote_secondary

实际上对这个AIL语言，笔者也不是很了解，这里就只需要了解它大致干了什么就行，可以看到在这里频繁地出现了zygote-start 这个语句，大致就可以分析出这个init.rc文件中将会启动zygote进程，这也是Android系统中一个特殊的进程，所以我们可以理解为解析init.rc这个文件过程中就会启动Zygote进程。

总结init进程

上面就是init进程主要干了什么事情，在这里我们就可以先总结一下：

1. 首先创建和挂载启动所需的文件目录
1. 接着初始化和启动属性服务，设置信号处理函数
1. 最后解析init.rc文件，这个过程中将会启动Zygote进程

什么是Zygote进程

在Android系统中，Zygote进程（Zygote process）是一个特殊的进程，它是应用程序的孵化器（orphanage）和模板进程（template process）。它在系统启动时被初始化，作为应用程序的起点，负责创建和管理其他应用程序进程。

Zygote进程的主要功能包括：

预加载类和资源：Zygote进程在启动过程中会预加载一些常用的类和资源，以加速应用程序的启动速度。这样，在创建新的应用程序进程时，可以通过复制Zygote进程的内存空间来避免重新加载这些类和资源，从而提高应用程序的启动性能。
创建应用程序进程：当系统接收到要运行一个新的应用程序的请求时，Zygote进程会作为模板进程，通过复制自身的内存空间来创建一个新的应用程序进程。这样，新的应用程序进程将继承Zygote进程的状态和资源，从而加速应用程序的启动过程。
分配应用程序的虚拟机（VM）：每个应用程序进程都有自己的虚拟机实例。Zygote进程在创建应用程序进程时，会为该进程分配一个独立的虚拟机，以便应用程序可以在自己的虚拟机中执行代码。
处理系统共享库：Zygote进程会加载和管理系统共享库（shared library），以便应用程序可以共享这些库。这样，多个应用程序可以在内存中共享同一个系统库的实例，节省系统资源并提高运行效率。

通过使用Zygote进程，Android系统可以快速创建和启动应用程序进程，减少资源的重复加载和内存占用，提高应用程序的响应速度和性能。Zygote进程在系统启动时创建，并一直运行在后台，负责处理应用程序的孵化和管理工作。

Zygote进程的启动

Zygote的启动脚本

我们先来看Zygote进程的启动脚本，打开system/core/rootdir/init.zygote64.rc：

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system
    socket usap_pool_primary stream 660 root system
    onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
    onrestart write /sys/power/state on
    # NOTE: If the wakelock name here is changed, then also
    # update it in SystemSuspend.cpp
    onrestart write /sys/power/wake_lock zygote_kwl
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart media.tuner
    onrestart restart netd
    onrestart restart wificond
    task_profiles ProcessCapacityHigh MaxPerformance
    critical window=${zygote.critical_window.minute:-off} target=zygote-fatal

其中定义了一个名为zygote的service，启动路径为/system/bin/app_process64，也就是对应第一行最开始的内容，后面的其与内容都是对这个service进行修饰的内容；除此之外我们还可以发现启动的类名为main，也就是第二行的内容。

这个文件中定义的东西也是AIL，所以也是需要进行解析的,解析之后，实际上就会启动路径下的的文件，再说具体一点，实际上是FrameWorks目录下的文件：frameworks/base/cmds/app_process/app_main.cpp，我们再看这个文件的内容：

	....
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else if (!className.isEmpty()) {
        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.");
    }
    ....

这里依旧截取最重要的部分，在这里将会先判断当前是否运行在Zygote进程中，如果是，就会调用runtime.start函数，为什么要先判断呢？因为Zygote进程都是通过fork自身来创建子进程的，这样Zygote以及它的子进程都可以进入app_main.cpp的main函数，因此需要区分进程。

接下来我们看这个runtime的start函数做了什么。

AndroidRuntime的start方法

实际上这个start方法主要就是用来进行JNI调用的，即在C++中调用Java方法，我们马上来看这个方法：

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

    //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
    //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);

    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) { //1 启动虚拟机
        return;
    }
    onVmCreated(env); //2 创建虚拟机

    /*
     * Register android functions.
     */
    if (startReg(env) < 0) { //3 注册Java方法
        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;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
    classNameStr = env->NewStringUTF(className);//4 获得类名
    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);
    }

    /*
     * Start VM.  This thread becomes the main thread of the VM, and will
     * not return until the VM exits.
     */
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
    jclass startClass = env->FindClass(slashClassName); //5 找到类名对应的类--ZygoteInit
    if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");//6 找到对应类的main方法
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);//7 调用找到的main方法，从这里开始也进入了Java框架层

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

依旧是看重点，代码中我已经进行了一定的注释，总的来说之前提到的runtime.start(“com.android.internal.os.ZygoteInit”, args, zygote)干的事情就是：

启动JVM虚拟机
注册Java方法，用于JNI调用
找到对应的类名，也就是ZygoteInit
找到对应的类和main方法
调用这个找到的main方法

所以说，这么一套下来最后是会调用ZygoteInit这个Java类，实际上这也意味着启动正式进入到了Java层而不是之前的C++层。

进入Java层-ZygoteInit的main方法

上面说到我们正式进入到了Java层了，接下来就来看ZygoteInit的main方法：

public static void main(String[] argv) {
        ....
        try {
           .....
            boolean startSystemServer = false;
            String zygoteSocketName = "zygote";
            String abiList = null;
            boolean enableLazyPreload = false;
            for (int i = 1; i < argv.length; i++) {
                if ("start-system-server".equals(argv[i])) {
                    startSystemServer = true;
                } else if ("--enable-lazy-preload".equals(argv[i])) {
                    enableLazyPreload = 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)) {
                    zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
                } else {
                    throw new RuntimeException("Unknown command line argument: " + argv[i]);
                }
            }

 			......
            Zygote.initNativeState(isPrimaryZygote);

            ZygoteHooks.stopZygoteNoThreadCreation();

            zygoteServer = new ZygoteServer(isPrimaryZygote);//1

            if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);//2


                if (r != null) {
                    r.run();
                    return;
                }
            }

            Log.i(TAG, "Accepting command socket connections");


            caller = zygoteServer.runSelectLoop(abiList);//3
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with fatal exception", ex);
            throw ex;
        } finally {
            if (zygoteServer != null) {
                zygoteServer.closeServerSocket();
            }
        }
		.....
    }

这里我们还是看重点，主要就是上面标注出来的三处注释处，注释一处调用了：zygoteServer = new ZygoteServer(isPrimaryZygote)，这个方法将会创建出一个zygoteServer，就是一个孵化器服务，同时构造方法内部会创建出一个Socket，这个显然是用来给其他进程调用的；注释二处的Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer)就是用来启动各种系统服务的；注释三处，zygoteServer孵化器服务就开始等待请求了，具体来说，是等待AMS（Activity Manger Server）的请求。

我们也对这个ZygoteInit的内容进行一些总结：

首先调用构造函数创建孵化器服务(Zygote)和端口
然后开启各种各样的系统服务
最后孵化器服务(zygoteServer)开始进行等待AMS的请求

总结从开机到进入Zygote进程的初始化部分

那么到这里为止，我们已经进入到了Java框架层的第一个方法了，现在我们开始从开机开始阶段性总结一下目前为止的流程：

首先开机上电，执行引导程序，完成Linux层的初始化，然后进入到了init流程
init流程中将系统文件进行了创建和挂载，初始化和启动属性服务，设置信号处理函数，最后就开始解析init.rc文件
解析init.rc文件时将会最终调用到frameworks/base/cmds/app_process/app_main.cpp的main函数
在这个app_main中最终会调用到AndroidRuntime.start对应的ZygoteInit的main方法，而实际上这个AndroidRuntime.start方法是JNI调用，它将会启动JVM并且注册Java方法，最后调用Java方法，在这里也就是ZygoteInit的main方法，完成了从C++层进入Java层
ZygoteInit的main方法中创建并启动了zygote服务和其他的系统服务，最后zygote服务会等待AMS的请求

Tai_Monster

关注

4
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
Android系统的启动流程（一）：进入Zygote进程的初始化

init进程是Android系统中用户空间的第一个进程，进程号为1，是Android系统启动流程中一个关键的步骤，作为第一个进程，他被赋予了许多重要的工作流程。init进程是由多个源文件共同组成的。首先创建和挂载启动所需的文件目录接着初始化和启动属性服务，设置信号处理函数最后解析init.rc文件，这个过程中将会启动Zygote进程。
复制链接

扫一扫