【Android体系启动】 Android Zygote 历程启动流程源码解析 ...

【Android体系启动】 Android Zygote 历程启动流程源码解析

媒介

• 文章源码按照AOSP官网源码platform/superproject/main - Android Code Search代码进行解读；
  
• 如有不妥之处，麻烦指出作者进行修正
  

代码位置

   

• frameworks/base/cmds/app_process/app_main.cpp
  

    题外话， 之前找zygote源码的时候，本来想直接通过历程名找这个模块的源码，效果发现根本没有zygote这个名字的下令。通过下令查找到对应的历程目录发现，原来的历程的名字当时编译为app_process，实际文件一般在/system/bin下面。
  源码解析

Init拉起zygote

在system/core/rootdir/init.rc中，

1. # It is recommended to put unnecessary data/ initialization from post-fs-data
2. # to start-zygote in device's init.rc to unblock zygote start.
3. on zygote-start
4.     wait_for_prop odsign.verification.done 1
5.     # A/B update verifier that marks a successful boot.
6.     exec_start update_verifier
7.     start statsd
8.     start netd
9.     start zygote
10.     start zygote_secondary

复制代码

根据之前init.rc的官方README阐明文档，以及源码解析，均可得知这里start zygote开始了zygote服务；分析见下方。

1. Start a service running if it is not already running. Note that this is not synchronous, and even if it were, there is no guarantee that the operating system’s scheduler will execute the service sufficiently to guarantee anything about the service’s status. See the exec_start command for a synchronous version of start.
2. 如果服务尚未运行，则启动该服务。
3. 请注意，这不是同步的，即使它是同步的，也不能保证操作系统的调度程序会充分执行服务以确保服务的状态。
4. 参见 exec_start 命令，以获取 start 的同步版本。

复制代码

在init第二阶段的时候，有获取内置下令的逻辑，这部分下令用于解析执行init.rc

1. // system/core/init/init.cpp
2.         const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();
3.     Action::set_function_map(&function_map);

复制代码

这里的Map实际对应下面这个Map，而且可以得知start方法调用的是do_start；
do_start先从服务列表内里找到这个服务，然后调用封装好的Service::Start()方法进行调用。

2. // system/core/init/builtins.cpp
3. // Builtin-function-map start
4. const BuiltinFunctionMap& GetBuiltinFunctionMap() {
5.     constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
6.     // clang-format off
7.     static const BuiltinFunctionMap builtin_functions = {
8.         {"bootchart",               {1,     1,    {false,  do_bootchart}}},
9.         {"chmod",                   {2,     2,    {true,   do_chmod}}},
10.         {"chown",                   {2,     3,    {true,   do_chown}}},
11.         {"class_reset",             {1,     1,    {false,  do_class_reset}}},
12.         {"class_restart",           {1,     2,    {false,  do_class_restart}}},
13.         {"class_start",             {1,     1,    {false,  do_class_start}}},
14.         {"class_stop",              {1,     1,    {false,  do_class_stop}}},
15.         {"copy",                    {2,     2,    {true,   do_copy}}},
16.         {"copy_per_line",           {2,     2,    {true,   do_copy_per_line}}},
17.         {"domainname",              {1,     1,    {true,   do_domainname}}},
18.         {"enable",                  {1,     1,    {false,  do_enable}}},
19.         {"exec",                    {1,     kMax, {false,  do_exec}}},
20.         {"exec_background",         {1,     kMax, {false,  do_exec_background}}},
21.         {"exec_start",              {1,     1,    {false,  do_exec_start}}},
22.         {"export",                  {2,     2,    {false,  do_export}}},
23.         {"hostname",                {1,     1,    {true,   do_hostname}}},
24.         {"ifup",                    {1,     1,    {true,   do_ifup}}},
25.         {"init_user0",              {0,     0,    {false,  do_init_user0}}},
26.         {"insmod",                  {1,     kMax, {true,   do_insmod}}},
27.         {"installkey",              {1,     1,    {false,  do_installkey}}},
28.         {"interface_restart",       {1,     1,    {false,  do_interface_restart}}},
29.         {"interface_start",         {1,     1,    {false,  do_interface_start}}},
30.         {"interface_stop",          {1,     1,    {false,  do_interface_stop}}},
31.         {"load_exports",            {1,     1,    {false,  do_load_exports}}},
32.         {"load_persist_props",      {0,     0,    {false,  do_load_persist_props}}},
33.         {"load_system_props",       {0,     0,    {false,  do_load_system_props}}},
34.         {"loglevel",                {1,     1,    {false,  do_loglevel}}},
35.         {"mark_post_data",          {0,     0,    {false,  do_mark_post_data}}},
36.         {"mkdir",                   {1,     6,    {true,   do_mkdir}}},
37.         // TODO: Do mount operations in vendor_init.
38.         // mount_all is currently too complex to run in vendor_init as it queues action triggers,
39.         // imports rc scripts, etc.  It should be simplified and run in vendor_init context.
40.         // mount and umount are run in the same context as mount_all for symmetry.
41.         {"mount_all",               {0,     kMax, {false,  do_mount_all}}},
42.         {"mount",                   {3,     kMax, {false,  do_mount}}},
43.         {"perform_apex_config",     {0,     1,    {false,  do_perform_apex_config}}},
44.         {"umount",                  {1,     1,    {false,  do_umount}}},
45.         {"umount_all",              {0,     1,    {false,  do_umount_all}}},
46.         {"update_linker_config",    {0,     0,    {false,  do_update_linker_config}}},
47.         {"readahead",               {1,     2,    {true,   do_readahead}}},
48.         {"remount_userdata",        {0,     0,    {false,  do_remount_userdata}}},
49.         {"restart",                 {1,     2,    {false,  do_restart}}},
50.         {"restorecon",              {1,     kMax, {true,   do_restorecon}}},
51.         {"restorecon_recursive",    {1,     kMax, {true,   do_restorecon_recursive}}},
52.         {"rm",                      {1,     1,    {true,   do_rm}}},
53.         {"rmdir",                   {1,     1,    {true,   do_rmdir}}},
54.         {"setprop",                 {2,     2,    {true,   do_setprop}}},
55.         {"setrlimit",               {3,     3,    {false,  do_setrlimit}}},
56.         {"start",                   {1,     1,    {false,  do_start}}},
57.         {"stop",                    {1,     1,    {false,  do_stop}}},
58.         {"swapon_all",              {0,     1,    {false,  do_swapon_all}}},
59.         {"enter_default_mount_ns",  {0,     0,    {false,  do_enter_default_mount_ns}}},
60.         {"symlink",                 {2,     2,    {true,   do_symlink}}},
61.         {"sysclktz",                {1,     1,    {false,  do_sysclktz}}},
62.         {"trigger",                 {1,     1,    {false,  do_trigger}}},
63.         {"verity_update_state",     {0,     0,    {false,  do_verity_update_state}}},
64.         {"wait",                    {1,     2,    {true,   do_wait}}},
65.         {"wait_for_prop",           {2,     2,    {false,  do_wait_for_prop}}},
66.         {"write",                   {2,     2,    {true,   do_write}}},
67.     };
68.     // clang-format on
69.     return builtin_functions;
70. }
72. static Result<void> do_start(const BuiltinArguments& args) {
73.     Service* svc = ServiceList::GetInstance().FindService(args[1]);
74.     if (!svc) return Error() << "service " << args[1] << " not found";
75.     errno = 0;
76.     if (auto result = svc->Start(); !result.ok()) {
77.         return ErrorIgnoreEnoent() << "Could not start service: " << result.error();
78.     }
79.     return {};
80. }

复制代码

Service::Start()比力冗长，省略了部分代码；其实质是通过判断设置值决定是调用 fork() 照旧 clone() 来创建子历程或克隆历程。

1. Result<void> Service::Start() {
2.    
3.     // ...
4.    
5.     pid_t pid = -1;
6.     if (namespaces_.flags) {
7.         pid = clone(nullptr, nullptr, namespaces_.flags | SIGCHLD, nullptr);
8.     } else {
9.         pid = fork();
10.     }
12.     if (pid == 0) {
13.         umask(077);
14.         cgroups_activated.CloseWriteFd();
15.         setsid_finished.CloseReadFd();
16.         RunService(descriptors, std::move(cgroups_activated), std::move(setsid_finished));
17.         _exit(127);
18.     } else {
19.         cgroups_activated.CloseReadFd();
20.         setsid_finished.CloseWriteFd();
21.     }
23.     if (pid < 0) {
24.         pid_ = 0;
25.         return ErrnoError() << "Failed to fork";
26.     }
28.     // ...
30.     LOG(INFO) << "... started service '" << name_ << "' has pid " << pid_;
32.     return {};
33. }

复制代码

然后补充一下，这个是system/core/rootdir/init.zygote32.rc，zygote通过initr.rc拉起时会逐一解析这些下令而且启动。（如果是64位体系，则为init.zygote64.rc）

1. service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
3.     class main
4.     priority -20
5.     user root
6.     group root readproc reserved_disk
7.     socket zygote stream 660 root system
8.     socket usap_pool_primary stream 660 root system
9.     onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
10.     onrestart write /sys/power/state on
11.     # NOTE: If the wakelock name here is changed, then also
12.     # update it in SystemSuspend.cpp
13.     onrestart write /sys/power/wake_lock zygote_kwl
14.     onrestart restart audioserver
15.     onrestart restart cameraserver
16.     onrestart restart media
17.     onrestart restart media.tuner
18.     onrestart restart netd
19.     onrestart restart wificond
20.     task_profiles ProcessCapacityHigh
21.     critical window=${zygote.critical_window.minute:-off} target=zygote-fatal

复制代码

Zygote Main

上面已经讲完Init如何拉起zygote了。下面进入zygote模块本身的代码。从历程名查找到该下令为app_process，然后再从bp大概mk源码中找app_process，即可找到这个下令的位置了。

1. int main(int argc, char* const argv[])
2. {
3.    
4.     // --------- LOG -----------
5.     if (!LOG_NDEBUG) {
6.       String8 argv_String;
7.       for (int i = 0; i < argc; ++i) {
8.         argv_String.append(""");
9.         argv_String.append(argv[i]);
10.         argv_String.append("" ");
11.       }
12.       ALOGV("app_process main with argv: %s", argv_String.c_str());
13.     }
15.     // ------------ Runtime初始化 ------------
16.     AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
17.     // Process command line arguments
18.     // ignore argv[0]
19.     argc--;
20.     argv++;
22.     // Everything up to '--' or first non '-' arg goes to the vm.
23.     //
24.     // The first argument after the VM args is the "parent dir", which
25.     // is currently unused.
26.     //
27.     // After the parent dir, we expect one or more the following internal
28.     // arguments :
29.     //
30.     // --zygote : Start in zygote mode
31.     // --start-system-server : Start the system server.
32.     // --application : Start in application (stand alone, non zygote) mode.
33.     // --nice-name : The nice name for this process.
34.     //
35.     // For non zygote starts, these arguments will be followed by
36.     // the main class name. All remaining arguments are passed to
37.     // the main method of this class.
38.     //
39.     // For zygote starts, all remaining arguments are passed to the zygote.
40.     // main function.
41.     //
42.     // Note that we must copy argument string values since we will rewrite the
43.     // entire argument block when we apply the nice name to argv0.
44.     //
45.     // As an exception to the above rule, anything in "spaced commands"
46.     // goes to the vm even though it has a space in it.
47.     const char* spaced_commands[] = { "-cp", "-classpath" };
48.     // Allow "spaced commands" to be succeeded by exactly 1 argument (regardless of -s).
49.     bool known_command = false;
51.     // ------------ 解析参数
52.     int i;
53.     for (i = 0; i < argc; i++) {
54.         if (known_command == true) {
55.           runtime.addOption(strdup(argv[i]));
56.           // The static analyzer gets upset that we don't ever free the above
57.           // string. Since the allocation is from main, leaking it doesn't seem
58.           // problematic. NOLINTNEXTLINE
59.           ALOGV("app_process main add known option '%s'", argv[i]);
60.           known_command = false;
61.           continue;
62.         }
64.         for (int j = 0;
65.              j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
66.              ++j) {
67.           if (strcmp(argv[i], spaced_commands[j]) == 0) {
68.             known_command = true;
69.             ALOGV("app_process main found known command '%s'", argv[i]);
70.           }
71.         }
73.         if (argv[i][0] != '-') {
74.             break;
75.         }
76.         if (argv[i][1] == '-' && argv[i][2] == 0) {
77.             ++i; // Skip --.
78.             break;
79.         }
81.         runtime.addOption(strdup(argv[i]));
82.         // The static analyzer gets upset that we don't ever free the above
83.         // string. Since the allocation is from main, leaking it doesn't seem
84.         // problematic. NOLINTNEXTLINE
85.         ALOGV("app_process main add option '%s'", argv[i]);
86.     }
88.     // Parse runtime arguments.  Stop at first unrecognized option.
89.     bool zygote = false;
90.     bool startSystemServer = false;
91.     bool application = false;
92.     String8 niceName;
93.     String8 className;
95.     ++i;  // Skip unused "parent dir" argument.
96.     while (i < argc) {
97.         const char* arg = argv[i++];
98.         if (strcmp(arg, "--zygote") == 0) {
99.             zygote = true;
100.             niceName = ZYGOTE_NICE_NAME;
101.         } else if (strcmp(arg, "--start-system-server") == 0) {
102.             startSystemServer = true;
103.         } else if (strcmp(arg, "--application") == 0) {
104.             application = true;
105.         } else if (strncmp(arg, "--nice-name=", 12) == 0) {
106.             niceName = (arg + 12);
107.         } else if (strncmp(arg, "--", 2) != 0) {
108.             className = arg;
109.             break;
110.         } else {
111.             --i;
112.             break;
113.         }
114.     }
116.     Vector<String8> args;
117.     if (!className.empty()) {
118.         // We're not in zygote mode, the only argument we need to pass
119.         // to RuntimeInit is the application argument.
120.         //
121.         // The Remainder of args get passed to startup class main(). Make
122.         // copies of them before we overwrite them with the process name.
123.         args.add(application ? String8("application") : String8("tool"));
124.         runtime.setClassNameAndArgs(className, argc - i, argv + i);
126.         if (!LOG_NDEBUG) {
127.           String8 restOfArgs;
128.           char* const* argv_new = argv + i;
129.           int argc_new = argc - i;
130.           for (int k = 0; k < argc_new; ++k) {
131.             restOfArgs.append(""");
132.             restOfArgs.append(argv_new[k]);
133.             restOfArgs.append("" ");
134.           }
135.           ALOGV("Class name = %s, args = %s", className.c_str(), restOfArgs.c_str());
136.         }
137.     } else {
138.         // We're in zygote mode.
139.         maybeCreateDalvikCache();
141.         if (startSystemServer) {
142.             args.add(String8("start-system-server"));
143.         }
145.         char prop[PROP_VALUE_MAX];
146.         if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
147.             LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
148.                 ABI_LIST_PROPERTY);
149.             return 11;
150.         }
152.         String8 abiFlag("--abi-list=");
153.         abiFlag.append(prop);
154.         args.add(abiFlag);
156.         // In zygote mode, pass all remaining arguments to the zygote
157.         // main() method.
158.         for (; i < argc; ++i) {
159.             args.add(String8(argv[i]));
160.         }
161.     }
163.     if (!niceName.empty()) {
164.         runtime.setArgv0(niceName.c_str(), true /* setProcName */);
165.     }
167.     // -------------------- runtime start
168.     if (zygote) {
169.         runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
170.     } else if (!className.empty()) {
171.         runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
172.     } else {
173.         fprintf(stderr, "Error: no class name or --zygote supplied.\n");
174.         app_usage();
175.         LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
176.     }
177. }

复制代码

上面主要干了这几件大事：
Debug Logging：如果 LOG_NDEBUG 为 false，将下令行参数以调试日记的形式输出。
AppRuntime 初始化：创建 AppRuntime 实例，用于处理应用程序的运行时环境。
处理下令行参数

• 忽略程序名 argv[0]。
  
• 将一些特定的下令行参数添加到运行时选项中。
  
• 根据 “–” 或非 ‘-’ 开头的参数分隔下令行参数，一部分传递给虚拟机（VM），一部分用于启动类的 main() 方法。
  

解析运行时参数

• 根据特定参数设置标志和属性（如 --zygote、--start-system-server、--application、--nice-name=<name>）。
  
• 如果遇到 “–” 开头的参数或非 ‘-’ 开头的参数，则制止解析。
  

预备运行时参数列表

• 如果存在类名 (className)，则将其作为参数传递给 RuntimeInit。
  
• 在 zygote 模式下，预备 ABI 列表和其他参数传递给 ZygoteInit。
  

设置历程名称

• 如果指定了 --nice-name=<name>，则设置历程名称。
  

根据模式调用 runtime 的 start() 方法

• 如果是 zygote 模式，则调用 start() 方法启动 ZygoteInit。
  
• 如果存在类名 (className)，则调用 start() 方法启动 RuntimeInit。
  
• 否则，输出错误信息并退出程序。
  

总的来说就是，预备AppRuntime，解析参数，设置历程名，调用runtime start()方法。
从上面zygote的rc文件也可以看到，一开始的参数为–start-system-server

1. service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

复制代码

AppRuntime start()

   frameworks/base/core/jni/AndroidRuntime.cpp

1. /*
2. * Start the Android runtime.  This involves starting the virtual machine
3. * and calling the "static void main(String[] args)" method in the class
4. * named by "className".
5. *
6. * Passes the main function two arguments, the class name and the specified
7. * options string.
8. */
9. void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
10. {
11.     // 打印启动信息，包括类名和用户ID
12.     ALOGD(">>>>>> START %s uid %d <<<<<<\n",
13.             className != NULL ? className : "(unknown)", getuid());
15.     // 判断是否是主要的 zygote 进程
16.     static const String8 startSystemServer("start-system-server");
17.     bool primary_zygote = false;
19.     // 检查是否需要打印启动事件
20.     for (size_t i = 0; i < options.size(); ++i) {
21.         if (options[i] == startSystemServer) {
22.             primary_zygote = true;
23.             const int LOG_BOOT_PROGRESS_START = 3000;
24.             LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
25.         }
26.     }
28.     // 设置环境变量
29.     const char* rootDir = getenv("ANDROID_ROOT");
30.     if (rootDir == NULL) {
31.         rootDir = "/system";
32.         if (!hasDir("/system")) {
33.             LOG_FATAL("No root directory specified, and /system does not exist.");
34.             return;
35.         }
36.         setenv("ANDROID_ROOT", rootDir, 1);
37.     }
39.     const char* artRootDir = getenv("ANDROID_ART_ROOT");
40.     if (artRootDir == NULL) {
41.         LOG_FATAL("No ART directory specified with ANDROID_ART_ROOT environment variable.");
42.         return;
43.     }
45.     const char* i18nRootDir = getenv("ANDROID_I18N_ROOT");
46.     if (i18nRootDir == NULL) {
47.         LOG_FATAL("No runtime directory specified with ANDROID_I18N_ROOT environment variable.");
48.         return;
49.     }
51.     const char* tzdataRootDir = getenv("ANDROID_TZDATA_ROOT");
52.     if (tzdataRootDir == NULL) {
53.         LOG_FATAL("No tz data directory specified with ANDROID_TZDATA_ROOT environment variable.");
54.         return;
55.     }
57.     // 初始化 JNI 调用
58.     JniInvocation jni_invocation;
59.     jni_invocation.Init(NULL);
60.     JNIEnv* env;
62.     // 启动虚拟机
63.     if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
64.         return;
65.     }
66.     onVmCreated(env);
68.     // 注册 Android 原生方法
69.     if (startReg(env) < 0) {
70.         ALOGE("Unable to register all android natives\n");
71.         return;
72.     }
74.     // 创建 String 数组，用于传递给 Java 的 main 方法
75.     jclass stringClass;
76.     jobjectArray strArray;
77.     jstring classNameStr;
79.     stringClass = env->FindClass("java/lang/String");
80.     assert(stringClass != NULL);
81.     strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
82.     assert(strArray != NULL);
83.     classNameStr = env->NewStringUTF(className);
84.     assert(classNameStr != NULL);
85.     env->SetObjectArrayElement(strArray, 0, classNameStr);
87.     for (size_t i = 0; i < options.size(); ++i) {
88.         jstring optionsStr = env->NewStringUTF(options.itemAt(i).c_str());
89.         assert(optionsStr != NULL);
90.         env->SetObjectArrayElement(strArray, i + 1, optionsStr);
91.     }
93.     // 调用 Java 的 main 方法启动应用程序
94.     char* slashClassName = toSlashClassName(className != NULL ? className : "");
95.     jclass startClass = env->FindClass(slashClassName);
96.     if (startClass == NULL) {
97.         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
98.         /* keep going */
99.     } else {
100.         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
101.             "([Ljava/lang/String;)V");
102.         if (startMeth == NULL) {
103.             ALOGE("JavaVM unable to find main() in '%s'\n", className);
104.             /* keep going */
105.         } else {
106.             env->CallStaticVoidMethod(startClass, startMeth, strArray);
107.         }
108.     }
109.     free(slashClassName);
111.     ALOGD("Shutting down VM\n");
112.     // 分离主线程
113.     if (mJavaVM->DetachCurrentThread() != JNI_OK)
114.         ALOGW("Warning: unable to detach main thread\n");
115.     // 销毁虚拟机
116.     if (mJavaVM->DestroyJavaVM() != 0)
117.         ALOGW("Warning: VM did not shut down cleanly\n");
118. }

复制代码

这里的主要职责：

• 初始化：打印启动信息、判断是否为systemserver历程、设置环境变量等；
  
• 初始化 JNI 调用和启动虚拟机
  
  
  • 使用 JniInvocation 初始化 JNI 调用；
    
  • 调用 startVm 方法启动虚拟机，并在虚拟机创建后调用 onVmCreated；
    
  • 调用 startReg 方法注册 Android 原生方法，内里遍历调用gRegJNI数组，数组是一组 JNI 函数的函数指针；
    
  
  
• 创建并传递参数给 Java 的 main 方法
  
  
  • 创建 String 类型的数组 strArray，用于传递给 Java 的 main 方法；
    
  • 将类名和选项字符串转换为 Java 的 String 对象，并设置到 strArray 中；
    
  
  
• 调用 Java 的 main 方法
  
  
  • 根据类名查找 startClass，并获取 main 方法的 startMeth；
    
  • 使用 env->CallStaticVoidMethod 调用 Java 的 main 方法启动应用程序；
    
  
  
• 关闭虚拟机
  
  
  • 执行完 main 方法后，分离主线程并销毁虚拟机。
    
  
  

这里总体就是初始化打印、环境变量、参数等，然后启动虚拟机-传递参数-调用main方法-关闭虚拟机。
不过通过观察这里会发现：

• 每次上层的历程启动会调用这个start方法，而start方法开启且仅开启了一个虚拟机，那就是zygote基础上每一个历程，都会对应一个本身的虚拟环境；
  
• 每个上层应用需要渐渐调到体系层，都通过zygote这里JNI方式进行了调用。
  

ZygoteInit.Main()

通过上面传下来的参数，“com.android.internal.os.ZygoteInit”，可以得知Java层的包名，以此找到Java代码。
   frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

1. /**
2. * This is the entry point for a Zygote process.  It creates the Zygote server, loads resources,
3. * and handles other tasks related to preparing the process for forking into applications.
4. *
5. * This process is started with a nice value of -20 (highest priority).  All paths that flow
6. * into new processes are required to either set the priority to the default value or terminate
7. * before executing any non-system code.  The native side of this occurs in SpecializeCommon,
8. * while the Java Language priority is changed in ZygoteInit.handleSystemServerProcess,
9. * ZygoteConnection.handleChildProc, and Zygote.childMain.
10. *
11. * @param argv  Command line arguments used to specify the Zygote's configuration.
12. */
13. @UnsupportedAppUsage
14. public static void main(String[] argv) {
15.     ZygoteServer zygoteServer = null;
17.     // 标记 Zygote 启动 确保在此后创建线程会抛出错误。
18.     // Mark zygote start. This ensures that thread creation will throw
19.     // an error.
20.     ZygoteHooks.startZygoteNoThreadCreation();
22.     // 调用 Os.setpgid(0, 0) 将 Zygote 放入自己的进程组。
23.     // Zygote goes into its own process group.
24.     try {
25.         Os.setpgid(0, 0);
26.     } catch (ErrnoException ex) {
27.         throw new RuntimeException("Failed to setpgid(0,0)", ex);
28.     }
30.     Runnable caller;
31.     try {
32.         // 解析命令行参数 argv，包括是否启动系统服务器 (start-system-server)、是否启用延迟预加载 (--enable-lazy-preload)、ABI 列表等。
33.         // Store now for StatsLogging later.
34.         final long startTime = SystemClock.elapsedRealtime();
35.         final boolean isRuntimeRestarted = "1".equals(
36.                 SystemProperties.get("sys.boot_completed"));
38.         String bootTimeTag = Process.is64Bit() ? "Zygote64Timing" : "Zygote32Timing";
39.         TimingsTraceLog bootTimingsTraceLog = new TimingsTraceLog(bootTimeTag,
40.                 Trace.TRACE_TAG_DALVIK);
41.         bootTimingsTraceLog.traceBegin("ZygoteInit");
42.         RuntimeInit.preForkInit();
44.         boolean startSystemServer = false;
45.         String zygoteSocketName = "zygote";
46.         String abiList = null;
47.         boolean enableLazyPreload = false;
48.         for (int i = 1; i < argv.length; i++) {
49.             if ("start-system-server".equals(argv[i])) {
50.                 startSystemServer = true;
51.             } else if ("--enable-lazy-preload".equals(argv[i])) {
52.                 enableLazyPreload = true;
53.             } else if (argv[i].startsWith(ABI_LIST_ARG)) {
54.                 abiList = argv[i].substring(ABI_LIST_ARG.length());
55.             } else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
56.                 zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
57.             } else {
58.                 throw new RuntimeException("Unknown command line argument: " + argv[i]);
59.             }
60.         }
62.         final boolean isPrimaryZygote = zygoteSocketName.equals(Zygote.PRIMARY_SOCKET_NAME);
63.         if (!isRuntimeRestarted) {
64.             if (isPrimaryZygote) {
65.                 FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
66.                         BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__ZYGOTE_INIT_START,
67.                         startTime);
68.             } else if (zygoteSocketName.equals(Zygote.SECONDARY_SOCKET_NAME)) {
69.                 FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
70.                         BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__SECONDARY_ZYGOTE_INIT_START,
71.                         startTime);
72.             }
73.         }
75.         if (abiList == null) {
76.             throw new RuntimeException("No ABI list supplied.");
77.         }
79.         // 记录启动时间、预加载
80.         // In some configurations, we avoid preloading resources and classes eagerly.
81.         // In such cases, we will preload things prior to our first fork.
82.         // 根据配置，预加载资源和类。如果未启用延迟预加载，则在第一次fork()之前预加载。
83.         if (!enableLazyPreload) {
84.             bootTimingsTraceLog.traceBegin("ZygotePreload");
85.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
86.                     SystemClock.uptimeMillis());
87.             preload(bootTimingsTraceLog);
88.             EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
89.                     SystemClock.uptimeMillis());
90.             bootTimingsTraceLog.traceEnd(); // ZygotePreload
91.         }
93.         // Do an initial gc to clean up after startup
94.         bootTimingsTraceLog.traceBegin("PostZygoteInitGC");
95.         gcAndFinalize();
96.         bootTimingsTraceLog.traceEnd(); // PostZygoteInitGC
98.         bootTimingsTraceLog.traceEnd(); // ZygoteInit
100.         // 初始化native状态
101.         Zygote.initNativeState(isPrimaryZygote);
103.         // 停止 Zygote 无线程创建标记
104.         ZygoteHooks.stopZygoteNoThreadCreation();
106.         // 创建 ZygoteServer 实例。
107.         zygoteServer = new ZygoteServer(isPrimaryZygote);
109.         
110.         // 如果需要启动SystemServer，则调用 forkSystemServer 创建SystemServer的子进程，并在子进程中运行。
111.         if (startSystemServer) {
112.             Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
114.             // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
115.             // child (system_server) process.
116.             if (r != null) {
117.                 r.run();
118.                 return;
119.             }
120.         }
122.         
123.         // 接受命令套接字连接
124.         Log.i(TAG, "Accepting command socket connections");
126.         // select 循环在 fork 后在子进程中提前返回，并在 zygote 中永远循环
127.         // The select loop returns early in the child process after a fork and
128.         // loops forever in the zygote.
129.         caller = zygoteServer.runSelectLoop(abiList);
130.     } catch (Throwable ex) {
131.         Log.e(TAG, "System zygote died with fatal exception", ex);
132.         throw ex;
133.     } finally {
134.         // 异常处理和资源清理 在最后关闭 zygoteServer 的服务器套接字。
135.         if (zygoteServer != null) {
136.             zygoteServer.closeServerSocket();
137.         }
138.     }
140.     // We're in the child process and have exited the select loop. Proceed to execute the
141.     // command.
142.     // 执行命令 如果 caller 不为 null，则在子进程中执行命令。
143.     if (caller != null) {
144.         caller.run();
145.     }
146. }

复制代码

  补充一下注释翻译（这里告诉了修改历程优先级的native层和java层的地方）：
  这是 Zygote 历程的入口点。它创建 Zygote 服务器、加载资源并处理与预备历程以分叉到应用程序相关的其他任务。
  此历程以 -20（最高优先级）的 nice 值启动。所有流入新历程的路径都必须将优先级设置为默认值或在执行任何非体系代码之前终止。native方面发生在 SpecializeCommon 中， 而 Java 语言优先级在 ZygoteInit.handleSystemServerProcess、ZygoteConnection.handleChildProc 和 Zygote.childMain 中更改。
  这里主要的职责有：

• 初始化：标志zygote无线程启动、设置历程组、处理下令行参数；
         int setpgid(pid_t pid, pid_t pgid) 可以将一个历程加入一个现有的历程组，大概创建一个新的历程组且当前调用历程作为历程组组长（setpgid(0, 0)）。pid 参数只能是 0 （当前历程）、当前历程 id、子历程 id（孙子历程不行）。
  
• 记录启动时间，并根据是否为主要 Zygote 历程写入启动时间事件；
  
• 预加载，根据设置在第一次fork前预加载；
  
• 初始化native层状态；
  
• 制止标志zygote无线程启动；
  
• 创建 ZygoteServer，而且启动systemserver；
  
• zygoteServer.runSelectLoop(abiList)，建立systemserver和zygote的socket通信；
  
• 关闭zygoteserver的socket；
  

然后挑一些告急的职责细讲一下：
ZygoteInit PreLoad

这里预加载的主要是一些体系类、资源、共享库so、文字、webview等等；

1.     static void preload(TimingsTraceLog bootTimingsTraceLog) {
2.         Log.d(TAG, "begin preload");
3.         bootTimingsTraceLog.traceBegin("BeginPreload");
4.         beginPreload();
5.         bootTimingsTraceLog.traceEnd(); // BeginPreload
6.         bootTimingsTraceLog.traceBegin("PreloadClasses");
7.         preloadClasses();
8.         bootTimingsTraceLog.traceEnd(); // PreloadClasses
9.         bootTimingsTraceLog.traceBegin("CacheNonBootClasspathClassLoaders");
10.         cacheNonBootClasspathClassLoaders();
11.         bootTimingsTraceLog.traceEnd(); // CacheNonBootClasspathClassLoaders
12.         bootTimingsTraceLog.traceBegin("PreloadResources");
13.         Resources.preloadResources();
14.         bootTimingsTraceLog.traceEnd(); // PreloadResources
15.         Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadAppProcessHALs");
16.         nativePreloadAppProcessHALs();
17.         Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
18.         Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PreloadGraphicsDriver");
19.         maybePreloadGraphicsDriver();
20.         Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
21.         preloadSharedLibraries();
22.         preloadTextResources();
23.         // Ask the WebViewFactory to do any initialization that must run in the zygote process,
24.         // for memory sharing purposes.
25.         WebViewFactory.prepareWebViewInZygote();
26.         endPreload();
27.         warmUpJcaProviders();
28.         Log.d(TAG, "end preload");
30.         sPreloadComplete = true;
31.     }

复制代码

而且preload也有个条件条件 enableLazyPreload = true --> 带有–enable-lazy-preload，只有system/core/rootdir/init.zygote64_32.rc才有这个参数 --> 只有在32和64位均需要启动的时候，才需要preload；
   

• init.zygote32.rc：zygote 历程对应的执行程序是 app_process (纯 32bit 模式)
  
• init.zygote64.rc：zygote 历程对应的执行程序是 app_process64 (纯 64bit 模式)
  
• init.zygote32_64.rc：启动两个 zygote 历程 (名为 zygote 和 zygote_secondary)，对应的执行程序分别是 app_process32 (主模式)、app_process64
  
• init.zygote64_32.rc：启动两个 zygote 历程 (名为 zygote 和 zygote_secondary)，对应的执行程序分别是 app_process64 (主模式)、app_process32
  

  ZygoteInit forkSystemServer

1.     /**
2.      * Prepare the arguments and forks for the system server process.
3.      *
4.      * @return A {@code Runnable} that provides an entrypoint into system_server code in the child
5.      * process; {@code null} in the parent.
6.      */
7.     private static Runnable forkSystemServer(String abiList, String socketName,
8.             ZygoteServer zygoteServer) {
9.         long capabilities = posixCapabilitiesAsBits(
10.                 OsConstants.CAP_IPC_LOCK,
11.                 OsConstants.CAP_KILL,
12.                 OsConstants.CAP_NET_ADMIN,
13.                 OsConstants.CAP_NET_BIND_SERVICE,
14.                 OsConstants.CAP_NET_BROADCAST,
15.                 OsConstants.CAP_NET_RAW,
16.                 OsConstants.CAP_SYS_MODULE,
17.                 OsConstants.CAP_SYS_NICE,
18.                 OsConstants.CAP_SYS_PTRACE,
19.                 OsConstants.CAP_SYS_TIME,
20.                 OsConstants.CAP_SYS_TTY_CONFIG,
21.                 OsConstants.CAP_WAKE_ALARM,
22.                 OsConstants.CAP_BLOCK_SUSPEND
23.         );
24.         /* Containers run without some capabilities, so drop any caps that are not available. */
25.         StructCapUserHeader header = new StructCapUserHeader(
26.                 OsConstants._LINUX_CAPABILITY_VERSION_3, 0);
27.         StructCapUserData[] data;
28.         try {
29.             data = Os.capget(header);
30.         } catch (ErrnoException ex) {
31.             throw new RuntimeException("Failed to capget()", ex);
32.         }
33.         capabilities &= Integer.toUnsignedLong(data[0].effective) |
34.                 (Integer.toUnsignedLong(data[1].effective) << 32);
36.         /* Hardcoded command line to start the system server */
37.         String[] args = {
38.                 "--setuid=1000",
39.                 "--setgid=1000",
40.                 "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
41.                         + "1024,1032,1065,3001,3002,3003,3005,3006,3007,3009,3010,3011,3012",
42.                 "--capabilities=" + capabilities + "," + capabilities,
43.                 "--nice-name=system_server",
44.                 "--runtime-args",
45.                 "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
46.                 "com.android.server.SystemServer",
47.         };
48.         ZygoteArguments parsedArgs;
50.         int pid;
52.         try {
53.             ZygoteCommandBuffer commandBuffer = new ZygoteCommandBuffer(args);
54.             try {
55.                 parsedArgs = ZygoteArguments.getInstance(commandBuffer);
56.             } catch (EOFException e) {
57.                 throw new AssertionError("Unexpected argument error for forking system server", e);
58.             }
59.             commandBuffer.close();
60.             Zygote.applyDebuggerSystemProperty(parsedArgs);
61.             Zygote.applyInvokeWithSystemProperty(parsedArgs);
63.             if (Zygote.nativeSupportsMemoryTagging()) {
64.                 String mode = SystemProperties.get("persist.arm64.memtag.system_server", "");
65.                 if (mode.isEmpty()) {
66.                   /* The system server has ASYNC MTE by default, in order to allow
67.                    * system services to specify their own MTE level later, as you
68.                    * can't re-enable MTE once it's disabled. */
69.                   mode = SystemProperties.get("persist.arm64.memtag.default", "async");
70.                 }
71.                 if (mode.equals("async")) {
72.                     parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_ASYNC;
73.                 } else if (mode.equals("sync")) {
74.                     parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_SYNC;
75.                 } else if (!mode.equals("off")) {
76.                     /* When we have an invalid memory tag level, keep the current level. */
77.                     parsedArgs.mRuntimeFlags |= Zygote.nativeCurrentTaggingLevel();
78.                     Slog.e(TAG, "Unknown memory tag level for the system server: "" + mode + """);
79.                 }
80.             } else if (Zygote.nativeSupportsTaggedPointers()) {
81.                 /* Enable pointer tagging in the system server. Hardware support for this is present
82.                  * in all ARMv8 CPUs. */
83.                 parsedArgs.mRuntimeFlags |= Zygote.MEMORY_TAG_LEVEL_TBI;
84.             }
86.             /* Enable gwp-asan on the system server with a small probability. This is the same
87.              * policy as applied to native processes and system apps. */
88.             parsedArgs.mRuntimeFlags |= Zygote.GWP_ASAN_LEVEL_LOTTERY;
90.             if (shouldProfileSystemServer()) {
91.                 parsedArgs.mRuntimeFlags |= Zygote.PROFILE_SYSTEM_SERVER;
92.             }
94.             /* Request to fork the system server process */
95.             pid = Zygote.forkSystemServer(
96.                     parsedArgs.mUid, parsedArgs.mGid,
97.                     parsedArgs.mGids,
98.                     parsedArgs.mRuntimeFlags,
99.                     null,
100.                     parsedArgs.mPermittedCapabilities,
101.                     parsedArgs.mEffectiveCapabilities);
102.         } catch (IllegalArgumentException ex) {
103.             throw new RuntimeException(ex);
104.         }
106.         /* For child process */
107.         if (pid == 0) {
108.             if (hasSecondZygote(abiList)) {
109.                 waitForSecondaryZygote(socketName);
110.             }
112.             zygoteServer.closeServerSocket();
113.             return handleSystemServerProcess(parsedArgs);
114.         }
116.         return null;
117.     }

复制代码

内里的整体逻辑照旧很简单的 ， 就是整理出参数，然后调用zygote的方法；主要调用了applyDebuggerSystemProperty、applyInvokeWithSystemProperty、forkSystemServer方法，

• applyDebuggerSystemProperty：
         Applies debugger system properties to the zygote arguments.
  For eng builds all apps are debuggable with JDWP and ptrace.
  On userdebug builds if persist.debug.dalvik.vm.jdwp.enabled is 1 all apps are debuggable with JDWP and ptrace. Otherwise, the debugger state is specified via the “–enable-jdwp” flag in the
  spawn request.
  On userdebug builds if persist.debug.ptrace.enabled is 1 all apps are debuggable with ptrace.
      将调试器体系属性应用于 zygote 参数。
  对于 eng 版本，所有应用均可使用 JDWP 和 ptrace 进行调试。
  在 userdebug 版本中，如果 persist.debug.dalvik.vm.jdwp.enabled 为 1，则所有应用均可使用 JDWP 和 ptrace 进行调试。否则，调试器状态通过 spawn 请求中的“–enable-jdwp”标志指定。
  在 userdebug 版本中，如果 persist.debug.ptrace.enabled 为 1，则所有应用均可使用 ptrace 进行调试。
  
• applyInvokeWithSystemProperty：将invoke-with体系属性应用于zygote参数
  
• forkSystemServer 最终会调用到native层，fork出子历程；
  
• closeServerSocket 关闭socket通信；
  
• handleSystemServerProcess：完成新建子历程后剩余工作；
  

Q&A

为什么zygote要用socket，而不是用binder？

Zygote通信为什么用Socket，而不是Binder? - 简书 (jianshu.com)
参考

• platform/superproject/main - Android Code Search
  
• Android体系启动(二)- Zygote篇 - 掘金 (juejin.cn)
  
• Android O体系启动流程–zygote篇 - Vane的博客 | Vane’s Blog (vanelst.site)
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。