Android Zygote进程的启动

Android Zygote进程的启动(Android 10)

1 init.${ro.zygote}.rc 文件定义

前面分析过 Init 进程的启动，在 init.rc 文件中会配置 zygote 相关进程的启动。

system/core/rootdir/Android.mk

# system/core/rootdir/Android.mk
LOCAL_MODULE := init.rc
LOCAL_SRC_FILES := $(LOCAL_MODULE)
LOCAL_MODULE_CLASS := ETC
LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
LOCAL_REQUIRED_MODULES := fsverity_init

在 init.rc 中会 import 其他脚本，如 import /init.${ro.zygote}.rc

# system/core/rootdir/init.zygote.rc
# 启动 zygote 进程
# 名字 zygote
# 名字对应的程序 /system/bin/app_process
# 参数 -Xzygote /system/bin --zygote --start-system-server
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20 
    user root #用户权限
    group root readproc reserved_disk #所属用户组
    socket zygote stream 660 root system  # 创建名为dev/socket/zygote 的socket，返回fd给启动它的进程
    socket usap_pool_primary stream 660 root system  # 创建名为dev/socket/usap_pool_primary 的socket，返回fd给启动它的进程
    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

Zygote 进程能够重启的地方:

• servicemanager 进程被杀; (onresart)
• surfaceflinger 进程被杀; (onresart)
• Zygote 进程自己被杀; (oneshot=false)
• system_server 进程被杀; (waitpid)

2 Zygote 启动流程

由上可知，/system/bin/app_process 就是 zygote 进程运行的主程序，从定义app_process的地方可以找到：

# frameworks/base/cmds/app_process/Android.mk
app_process_src_files := \
    app_main.cpp \
app_process_cflags := \
    -Wall -Werror -Wunused -Wunreachable-code
include $(CLEAR_VARS)
# 模块名
LOCAL_MODULE:= app_process
LOCAL_MULTILIB := both
LOCAL_MODULE_STEM_32 := app_process32
LOCAL_MODULE_STEM_64 := app_process64

从app_main()入口函数开始，Zygote 启动过程的函数调用大概流程如下：

2.1 app_mai.cpp#main()

//frameworks/base/cmds/app_process/app_main.cpp
#if defined(__LP64__)
static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist64";
static const char ZYGOTE_NICE_NAME[] = "zygote64";
#else
static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist32";
static const char ZYGOTE_NICE_NAME[] = "zygote";
#endif

int main(int argc, char* const argv[])
{
   
    if (!LOG_NDEBUG) {
   
      String8 argv_String;
      for (int i = 0; i < argc; ++i) {
   
        argv_String.append("\"");
        argv_String.append(argv[i]);
        argv_String.append("\" ");
      }
      ALOGV("app_process main with argv: %s", argv_String.string());
    }
    //service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
	// 传到的参数 argv 为”-Xzygote /system/bin --zygote --start-system-server“
	// 创建 AppRuntime
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    // 忽略第一个参数 argv[0]
    argc--;
    argv++;

    // --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.
    const char* spaced_commands[] = {
    "-cp", "-classpath" };
    bool known_command = false;
    int i;
    for (i = 0; i < argc; i++) {
   
        // 。。。
        for (int j = 0;
             j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
             ++j) {
   
          if (strcmp(argv[i], spaced_commands[j]) == 0) {
   
            known_command = true;
            ALOGV("app_process main found known command '%s'", argv[i]);
          }
        }
        if (argv[i][0] != '-') {
   
            break;
        }
        if (argv[i][1] == '-' && argv[i][2] == 0) {
   
            ++i; // Skip --.
            break;
        }
        runtime.addOption(strdup(argv[i]));
    }

    // 参数解析
    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) {
   
        	// 对于 64 位系统 nice_name 为 zygote64; 32 位系统为 zygote
            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;
        }
    }

    Vector<String8> args;
    if (!className.isEmpty()) {
   
    	// 运行 application 或tool程序
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className, argc - i, argv + i);
    } else {
   
        // 进入 zygote 模式，创建 /data/dalvik-cache 路径
        maybeCreateDalvikCache();
		//是否启动 SystemServer
        if (startSystemServer) {
   
            args.add(String8("start-system-server"));
        }

        char prop[PROP_VALUE_MAX];
        if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
   
            LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
                ABI_LIST_PROPERTY);
            return 11;
        }

        String8 abiFlag("--abi-list=");
        abiFlag.append(prop);
        args.add(abiFlag);

        // In zygote mode, pass all remaining arguments to the zygote
        // main() method.
        for (; i < argc; ++i) {
   
            args.add(String8(argv[i]));
        }
    }
	// 设置进程名
    if (!niceName.isEmpty()) {
   
        runtime.setArgv0(