该解析从system/core/init/init.cpp初始化一系列文件系统，解析system/core/rootdir/init.rc文件启动Zygote进程分析至Zygote进程启动完成。
当我们驱动层启动完毕时首先会启动init进程，也就是用户进程。在system/core/init/init.cpp中会对init.rc文件进行解析，之后会孵化出一些进程和一些重要服务，最后会创建一个Zygote进程。这个实现过程的源码流程如下：
以下源码基于rk3399_industry Android7.1.2
init.rc
system/core/init/init.cpp
....
//构造出解析文件用的parser（解析器）对象
Parser& parser = Parser::GetInstance();
//为一些类型的关键字，创建特定的parser
parser.AddSectionParser("service",std::make_unique<ServiceParser>());
parser.AddSectionParser("on", std::make_unique<ActionParser>());
parser.AddSectionParser("import", std::make_unique<ImportParser>());
//开始解析init.rc文件
//init.rc文件是在init进程启动后执行的启动脚本，文件中记录着init进程需执行的操作。
//在Android系统中，使用init.rc和init.{ hardware }.rc两个文件。
//init.rc文件在Android系统运行过程中用于通用的环境设置与进程相关的定义
//init.{hardware}.rc（例如，高通有init.qcom.rc，MTK有init.mediatek.rc）
//用于定义Android在不同平台下的特定进程和环境设置等。
//此处加载的init.rc文件是system/core/rootdir/init.rc，此处记载放在下方解析
parser.ParseConfig("/init.rc");
....
system/core/rootdir/init.rc
import /init.environ.rc
import /init.usb.rc
import /init.${ro.hardware}.rc
import /init.usb.configfs.rc
import /init.${ro.zygote}.rc
....
init.rc中zygote相关的启动配置文件根据ro.zygote而定，ro.zygote的值可分为zygote32、zygote64、zygote32_64、zygote64_32四种，分别代表
- init.zygote32.rc：32位的zygote进程，对应的执行程序是app_process
- init.zygote64.rc：64位的zygote进程，对应的执行程序是app_process64
- init.zygote32_64.rc：启动两个zygote进程 (zygote和 zygote_secondary)，32位的app_process32 为主、64位的app_process64为辅。
- init.zygote64_32.rc：启动两个zygote进程 (zygote和 zygote_secondary)，64位的app_process64为主、32位的app_process32为辅。
ro.zygote的属性值定义是在 build/target/product/core_64_bit.mk
而core_64_bit.mk在device/rockchip/rk3399/product.mk内调用(根据芯片平台不同，对应的文件便不同，这里以RK3399为例子)，代码如下
device/rockchip/rk3399/product.mk
PRODUCT_RUNTIMES := runtime_libart_default
$(call inherit-product, device/rockchip/rk3399/device.mk)
$(call inherit-product, $(SRC_TARGET_DIR)/product/core_64_bit.mk)
其中$(SRC_TARGET_DIR)为build/target，所以对应的文件路径是
build/target/product/core_64_bit.mk
ifeq ($(strip $(TARGET_BOARD_PLATFORM_PRODUCT)), box)
PRODUCT_COPY_FILES += system/core/rootdir/init.zygote64_32.box.rc:root/init.zygote64_32.rc
else
PRODUCT_COPY_FILES += system/core/rootdir/init.zygote64_32.rc:root/init.zygote64_32.rc
endif
# 设置zygote属性以选择64位的主脚本，32位的从脚本，必须在core_minimal.mk中的脚本之前解析这一行
PRODUCT_DEFAULT_PROPERTY_OVERRIDES += ro.zygote=zygote64_32
TARGET_SUPPORTS_32_BIT_APPS := true
TARGET_SUPPORTS_64_BIT_APPS := true
由于我的源码系统种使用的是init.zygote64_32.rc文件，所以分析这个文件：
system/core/rootdir/init.zygote64_32.rc
#创建一个名为zygote的进程，对应的可执行程序路径为/system/bin/app_process64
# -Xzygote：jvm使用的参数；在AndroidRuntime.cpp类的startVm()函数中调用JNI_CreateJavaVM()时被使用。
# /system/bin：代表虚拟机程序所在目录
# --zygote 指明以ZygoteInit类作为虚拟机执行的入口，如果没有–zygote参数，则需要明确指定需要执行的类名。
# --start-system-server仅在指定–zygote参数时才有效，意思是告知ZygoteInit启动完毕后孵化出第一个进程SystemServe
# --socket-name=zygote:指定zygote所用到的socket名为zygote
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
class main
# 指定zygote服务使用到的名为zygote的socket，类型为stream，读写权限为660，用户为root，用户组为system。
socket zygote stream 660 root system
# onrestart 服务重启时执行的命令。
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
# writepid <file…> :fork 时将子进程的 pid 写入给定文件。
writepid /dev/cpuset/foreground/tasks
#与上面类似
service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary
class main
socket zygote_secondary stream 660 root system
onrestart restart zygote
writepid /dev/cpuset/foreground/tasks
#rc文件结构可以简单为
#service <name> <pathname> [ <argument> ]*
#<option>
#<option>
#service 服务名称 服务对应的命令的路径 命令的参数
#选项
#选项
init.zygote64_32.rc内部启动了两个 zygote 进程 (一个为64位的进程 zygote 和32位的进程zygote_secondary)，对应的执行程序分别是 app_process64 (主模式)和app_process32。
app_process的执行
接下来分析zygote64的可执行程序/system/bin/app_process64文件，app_process64由frameworks/base/cmds/app_process文件夹内部文件生成，app_process64的执行入口是目录下的app_main.cpp中的main函数，就从这里开始分析Zygote的启动流程：
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
//传入的参数根据上方分析得知有
//{-Xzygote , /system/bin , --zygote , --start-system-server , --socket-name=zygote}
// argc = 5
// argv[] = "-Xzygote /system/bin --zygote --start-system-server --socket-name=zygote";
int main(int argc, char* const argv[])
{
//下方有AppRuntime和 computeArgBlockSize的代码
//computeArgBlockSize方法会计算并且返回了传入参数的字节数
//之后会创建有AppRuntime对象runtime
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
// 进程命令行参数
// 忽略 argv[0] 即-Xzygote
argc--;
argv++;
// '--'开头或者第一个字符非'-'参数开头的所有内容都将进入vm。
// 虚拟机参数后的第一个参数是“父目录”，即/system/bin，目前还未使用。
// 在父目录之后，需要一个或多个内部参数:
// --zygote : zygote 模式启动
// --start-system-server : 启动系统服务
// --application : 开始应用(独立，非Zygote)模式。
// --nice-name : 进程名
// 对于非Zygote模式开始，这些参数后面将跟着启动类名。所有剩余的参数都传递给这个类的main方法。
// 对于zygote模式开始，所有剩余参数都传递给zygote main函数。
int i;
for (i = 0; i < argc; i++) {
if (argv[i][0] != '-') {
// argv[0] = “/system/bin”，所以直接就结束循环
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;
// 跳过未使用的“父目录（/system/bin）”参数，所以这里需要解析的参数数组为
// {--zygote , --start-system-server , --socket-name=zygote}
++i;
while (i < argc) {
const char* arg = argv[i++];
if (strcmp(arg, "--zygote") == 0) {//是否存在--zygote参数
//设置zygot参数为true，代表启动zygote模式
zygote = true;
niceName = ZYGOTE_NICE_NAME; //将niceName设置为"zygote"或者"zygote64"
} else if (strcmp(arg, "--start-system-server") == 0) {
//启动zygot模式存在--start-system-server，将startSystemServer设置为true
startSystemServer = true;
} else if (strcmp(arg, "--application") == 0) {//启动zygote模式不存在--application
application = true;
} else if (strncmp(arg, "--nice-name=", 12) == 0) {//启动zygot模式不存在--nice-name
niceName.setTo(arg + 12);
} else if (strncmp(arg, "--", 2) != 0) {//启动zygot模式时不成立
className.setTo(arg);
break;
} else {
--i;
break;
}
}
// 启动zygote时，上面运行完对应参数如下:
// zygote = true; niceName = ZYGOTE_NICE_NAME;startSystemServer = true;
// application = false; className =null;i=3;
Vector<String8> args;//该参数接下来要传入AndroidRuntime.start函数
if (!className.isEmpty()) { //启动zygote时未进入
// 假如我们要启动的不是zygote进程，而是application或tool程序
// 我们需要传递给RuntimeInit的唯一参数是应用程序参数。
// 其余的参数传递给启动类的main()。在使用进程名覆盖它们之前，对它们进行复制。
args.add(application ? String8("application") : String8("tool"));
runtime.setClassNameAndArgs(className, argc - i, argv + i);
} else {
//启动zygote时
maybeCreateDalvikCache();//创建/data/dalvik-cache路径,下方会放源码
if (startSystemServer) {
// 设置启动系统服务的参数
args.add(String8("start-system-server"));
}
char prop[PROP_VALUE_MAX];
// 获取到对应的ABI类型
// [ro.product.cpu.abilist] : [arm64-v8a, armeabi-v7a, armeabi]
// [ro.product.cpu.abilist32] : [armeabi-v7a, armeabi]
// [ro.product.cpu.abilist64] : [arm64-v8a]
// 根据我们的参数这里获得的是arm64-v8a
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);
// 将所有剩余参数传递给zygote main()方法。
// 启动zygote时这里argv就剩下“--socket-name=zygote”参数没加入了，添加进args
for (; i < argc; ++i) {
args.add(String8(argv[i]));
}
}
// 继续启动zygote，此时的args的值为
// {"start-system-server","--abi-list=ro.product.cpu.abilist64",--socket-name=zygote}
if (!niceName.isEmpty()) { //启动zygote时不成立
runtime.setArgv0(niceName.string());
set_process_name(niceName.string());
}
if (zygote) { // 启动zygot时成立，调用
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.");
return 10;
}
}
/************ 下面是内部调用的一些方法的源码，有需要可以看看 ************/
//这里计算并且返回了传入参数的字节数，这样的目的可以确保传入的四个参数是在一个连续的内存中。
static size_t computeArgBlockSize(int argc, char* const argv[]) {
uintptr_t start = reinterpret_cast<uintptr_t>(argv[0]);
uintptr_t end = reinterpret_cast<uintptr_t>(argv[argc - 1]);
end += strlen(argv[argc - 1]) + 1;
return (end - start);
}
//创建了/data/dalvik-cache目录，并修改该路径的用户、用户组和权限信息
static void maybeCreateDalvikCache() {
#if defined(__aarch64__)
static const char kInstructionSet[] = "arm64";
#elif defined(__x86_64__)
static const char kInstructionSet[] = "x86_64";
#elif defined(__arm__)
static const char kInstructionSet[] = "arm";
#elif defined(__i386__)
static const char kInstructionSet[] = "x86";
#elif defined (__mips__) && !defined(__LP64__)
static const char kInstructionSet[] = "mips";
#elif defined (__mips__) && defined(__LP64__)
static const char kInstructionSet[] = "mips64";
#else
#error "Unknown instruction set"
#endif
const char* androidRoot = getenv("ANDROID_DATA");//这里的androidRoot为"data
LOG_ALWAYS_FATAL_IF(androidRoot == NULL, "ANDROID_DATA environment variable unset");
char dalvikCacheDir[PATH_MAX];
const int numChars = snprintf(dalvikCacheDir, PATH_MAX,
"%s/dalvik-cache/%s", androidRoot, kInstructionSet);
LOG_ALWAYS_FATAL_IF((numChars >= PATH_MAX || numChars < 0),
"Error constructing dalvik cache : %s", strerror(errno));
//0711 只有属主有读、写、执行权限；而属组用户和其他用户只有执行权限。
int result = mkdir(dalvikCacheDir, 0711); //创建/data/dalvik-cache目录
LOG_ALWAYS_FATAL_IF((result < 0 && errno != EEXIST),
"Error creating cache dir %s : %s", dalvikCacheDir, strerror(errno));
//更改/data/dalvik-cache目录的用户与用户组为root用户、root用户组
result = chown(dalvikCacheDir, AID_ROOT, AID_ROOT);
LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno));
result = chmod(dalvikCacheDir, 0711);//更改/data/dalvik-cache路径的权限
LOG_ALWAYS_FATAL_IF((result < 0),
"Error changing dalvik-cache permissions : %s", strerror(errno));
}
由上面源码分析可得。由于rc内启动zygote时带有参数--zygote，所以最后会执行到runtime.start("com.android.internal.os.ZygoteInit", args, true);函数, runtime为AppRuntime类的对象，而AppRuntime类继承自AndroidRuntime，对应源码如下：
class AppRuntime : public AndroidRuntime
{
public:
AppRuntime(char* argBlockStart, const size_t argBlockLength)
: AndroidRuntime(argBlockStart, argBlockLength)
, mClass(NULL)
{
}
....
}
/** frameworks/base/core/jni/AndroidRuntime.cpp **/
//静态全局变量gCurRuntime指向AndroidRuntime对象本身,之后我们若需要获取AndroidRuntime对象，获取gCurRuntime就可以了。
static AndroidRuntime* gCurRuntime = NULL;
//创建AndroidRuntime对象
AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :
mExitWithoutCleanup(false),
mArgBlockStart(argBlockStart),
mArgBlockLength(argBlockLength)
{
SkGraphics::Init();
// 预先分配足够的空间来容纳相当数量的选项。
mOptions.setCapacity(20);
assert(gCurRuntime == NULL); // one per process
gCurRuntime = this;
}
在AppRuntime类其内部并没有start方法，实际调用的是AndroidRuntime类的start方法，接下来分析这个函数；
frameworks/base/core/jni/AndroidRuntime.cpp
/*
* 启动 Android runtime.这部分涉及到启动虚拟机并在名为“className”的类中调用其
* “static void main(String[] args)”方法。
* 向main函数传递两个参数，类名和指定的选项字符串。
*/
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
//此时的options为{"start-system-server","--abi-list=ro.product.cpu.abilist64",--socket-name=zygote}
static const String8 startSystemServer("start-system-server");
....
const char* rootDir = getenv("ANDROID_ROOT");//rootDir为"/system"目录
if (rootDir == NULL) {
rootDir = "/system";
if (!hasDir("/system")) {
LOG_FATAL("No root directory specified, and /android does not exist.");
return;
}
setenv("ANDROID_ROOT", rootDir, 1);
}
/* 启动虚拟机 */
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
if (startVm(&mJavaVM, &env, zygote) != 0) {
return;
}
onVmCreated(env);
/*
* 注册安卓jni函数。
*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
/*
* 创建一个带有参数的数组来保存类名和选项字符串参数
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
// String数组
strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
assert(strArray != NULL);
// 即ZygoteInit类名字符串
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
//将类名传入String数组strArray的第0个位置
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);
}
/*
* 启动虚拟机。该线程成为VM的主线程，并且在VM退出之前不会返回。
*/
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
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");//获取ZygoteInit类的main函数
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
//调用ZygoteInit.main函数
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
//释放slashClassName
free(slashClassName);
ALOGD("Shutting down VM\n");
if (mJavaVM->DetachCurrentThread() != JNI_OK)
ALOGW("Warning: unable to detach main thread\n");
if (mJavaVM->DestroyJavaVM() != 0)
ALOGW("Warning: VM did not shut down cleanly\n");
}
根据源码得出AndroidRuntime.start内可分为如下几步：
- 设置了rootDir的目录为/system；
- 通过startVm(&mJavaVM, &env, zygote)启动了虚拟机；
- 调用startReg(env)注册jni函数；
- 创建字符串数组来保存类和设置选项
- 将生成的字符串数组传入并调用ZygoteInit.main方法
AndroidRuntime.startVm:启动虚拟机
startVm内部定义了虚拟机的一系列参数，下面简单介绍一些虚拟机的参数，大部分省略掉了，太多了。
/*
* 启动Dalvik虚拟机。
*
* 传入的各种参数(大多数由系统属性决定)。还有一些由“mOptions” Vector更新。
*
* 成功返回0
*/
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
{
....
bool checkJni = false;
//JNI检测功能，用于native层调用jni函数时进行常规检测，比较弱字符串格式是否符合要求，资源是否正确释放。
//该功能一般用于早期系统调试或手机Eng版，对于User版往往不会开启，引用该功能比较消耗系统CPU资源，降低系统性能。
property_get("dalvik.vm.checkjni", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
checkJni = true;
} else if (strcmp(propBuf, "false") != 0) {
/* 判断kernel层是否开启 */
property_get("pa.kernel.android.checkjni", propBuf, "");
if (propBuf[0] == '1') {
checkJni = true;
}
}
ALOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
if (checkJni) {
/* 开启JNI检测功能 */
addOption("-Xcheck:jni");
}
//dalvik虚拟机启动模式
property_get("dalvik.vm.execution-mode", propBuf, "");
if (strcmp(propBuf, "int:portable") == 0) {
executionMode = kEMIntPortable;
} else if (strcmp(propBuf, "int:fast") == 0) {
executionMode = kEMIntFast;
} else if (strcmp(propBuf, "int:jit") == 0) {
executionMode = kEMJitCompiler;
}
//虚拟机产生的trace文件，主要用于分析系统问题，路径默认为/data/anr/traces.txt
parseRuntimeOption("dalvik.vm.stack-trace-file", stackTraceFileBuf, "-Xstacktracefile:");
....
/*
* 堆的默认启动和最大大小。根据不同的设备可以做相应的调整
*/
//dalvik.vm.heapstartsize:应用程序启动后为其分配的初始大小
parseRuntimeOption("dalvik.vm.heapstartsize", heapstartsizeOptsBuf, "-Xms", "4m");
//dalvik.vm.heapsize:单个虚拟机可分配的最大内存
parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");
//dalvik.vm.heapgrowthlimit:每个应用程序最大可分配内存
parseRuntimeOption("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
//dalvik.vm.heapminfree：堆最小空闲内存
parseRuntimeOption("dalvik.vm.heapminfree", heapminfreeOptsBuf, "-XX:HeapMinFree=");
//dalvik.vm.heapmaxfree：堆最大空闲内存
parseRuntimeOption("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
//dalvik.vm.heaptargetutilization：堆利用率
parseRuntimeOption("dalvik.vm.heaptargetutilization",
heaptargetutilizationOptsBuf,
"-XX:HeapTargetUtilization=");
//heapminfree、heapmaxfree、heaptargetutilization这三个值的设置则对垃圾回收（GC）的某些性能有影响。
/*
* JIT编译器相关配置。JIT：即时编译技术
*/
....
//确保有一个预加载的类文件preloaded-classes(由WritePreloadedClassFile.java生成)。
//在ZygoteInit类中会预加载工作将其中的classes提前加载到内存，以提高系统性能
if (!hasFile("/system/etc/preloaded-classes")) {
ALOGE("Missing preloaded-classes file, /system/etc/preloaded-classes not found: %s\n",
strerror(errno));
return -1;
}
....
//创建虚拟机
if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");
return -1;
}
return 0;
}
AndroidRuntime.startReg:注册jni函数
/*
* 向VM注册android jni函数。
*/
/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
ATRACE_NAME("RegisterAndroidNatives");
androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
ALOGV("--- registering native functions ---\n");
/*
* Every "register" function calls one or more things that return
* a local reference (e.g. FindClass). Because we haven't really
* started the VM yet, they're all getting stored in the base frame
* and never released. Use Push/Pop to manage the storage.
*/
env->PushLocalFrame(200);
//调用register_jni_procs进行jni接口注册,gRegJNI就是通过REG_JNI宏定义的jni函数数组
if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
env->PopLocalFrame(NULL);
return -1;
}
env->PopLocalFrame(NULL);
return 0;
}
static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
{
for (size_t i = 0; i < count; i++) {
if (array[i].mProc(env) < 0) {
#ifndef NDEBUG
ALOGD("----------!!! %s failed to load\n", array[i].mName);
#endif
return -1;
}
}
return 0;
}
//REG_JNI宏定义
#define REG_JNI(name) { name }
struct RegJNIRec {
int (*mProc)(JNIEnv*);
};
static const RegJNIRec gRegJNI[] = {
REG_JNI(register_com_android_internal_os_RuntimeInit),
REG_JNI(register_android_os_SystemClock),
REG_JNI(register_android_util_EventLog),
REG_JNI(register_android_util_Log),
REG_JNI(register_android_util_MemoryIntArray),
REG_JNI(register_android_util_PathParser),
REG_JNI(register_android_app_admin_SecurityLog),
REG_JNI(register_android_content_AssetManager),
REG_JNI(register_android_content_StringBlock),
REG_JNI(register_android_content_XmlBlock),
REG_JNI(register_android_text_AndroidCharacter),
REG_JNI(register_android_text_StaticLayout),
REG_JNI(register_android_text_AndroidBidi),
REG_JNI(register_android_view_InputDevice),
....
}
到此，虚拟机已经启动，jni函数也已经注册，这里只是简单分析，毕竟完整的分析就有点偏离启动流程了。之后进入ZygoteInit.main类的main函数；
ZygoteInit.main
frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
private static final String ABI_LIST_ARG = "--abi-list=";
private static final String SOCKET_NAME_ARG = "--socket-name=";
// 此时的argv[]为
// {"ZygoteInit","start-system-server","--abi-list=ro.product.cpu.abilist64",--socket-name=zygote}
public static void main(String argv[]) {
....
try {
// DDMS:DalvikDebugMonitorServer,Dalvik调试监控服务器
RuntimeInit.enableDdms();//开启DDMS监听，监听DDMS消息
// Start profiling the zygote initialization.
SamplingProfilerIntegration.start();//启动性能统计
boolean startSystemServer = false;
String socketName = "zygote";
String abiList = null;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
// 获得adb类型，此时为ro.product.cpu.abilist64
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
// socketName = zygote
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
if (abiList == null) {
// 没有获取到abi
throw new RuntimeException("No ABI list supplied.");
}
//创建名为zygote的的Server端socket
registerZygoteSocket(socketName);
preload();// 预加载类和资源
Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
SamplingProfilerIntegration.writeZygoteSnapshot();
//初始化gc
Trace.traceBegin(Trace.TRACE_TAG_DALVIK, "PostZygoteInitGC");
gcAndFinalize();
Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
Trace.traceEnd(Trace.TRACE_TAG_DALVIK);
// 关闭trace以防止fork出的进程trace错误
Trace.setTracingEnabled(false);
// Zygote进程卸载根存储空间，不太明白，希望大神赐教
Zygote.nativeUnmountStorageOnInit();
....
if (startSystemServer) {
//启动系统服务
startSystemServer(abiList, socketName);
}
//进入循环等待
//等待Activity管理服务ActivityManagerService请求Zygote进程创建新的应用程序进程
runSelectLoop(abiList);
closeServerSocket();
} catch (MethodAndArgsCaller caller) {
caller.run();
} catch (Throwable ex) {
Log.e(TAG, "Zygote died with exception", ex);
closeServerSocket();
throw ex;
}
}
registerZygoteSocket
registerZygoteSocket:创建名为zygote的Server端socket：用来等待ActivityManagerService请求Zygote进程创建新的应用程序进程。
private static LocalServerSocket sServerSocket;
private static final String ANDROID_SOCKET_PREFIX = "ANDROID_SOCKET_";
private static void registerZygoteSocket(String socketName) {
if (sServerSocket == null) {
int fileDesc;
final String fullSocketName = ANDROID_SOCKET_PREFIX + socketName;
try {
//env = ANDROID_SOCKET_zygote
String env = System.getenv(fullSocketName);
//将env转成文件描述符
fileDesc = Integer.parseInt(env);
} catch (RuntimeException ex) {
throw new RuntimeException(fullSocketName + " unset or invalid", ex);
}
try {
//根据fileDesc创建一个Server端socket
FileDescriptor fd = new FileDescriptor();
fd.setInt$(fileDesc);
//保存至ZygoteInit的静态成员变量sServerSocket
sServerSocket = new LocalServerSocket(fd);
} catch (IOException ex) {
throw new RuntimeException(
"Error binding to local socket '" + fileDesc + "'", ex);
}
}
}
创建完成后，会进行一些预加载类和资源，如果有需要会调用startSystemServer启动System进程，然后调用runSelectLoop进行循环等待。
runSelectLoop
runSelectLoop:进入循环等待,等待Activity管理服务ActivityManagerService(以下简称AMS)，请求Zygote进程创建新的应用程序进程。
/**
* 运行Zygote进程的循环等待，当新的连接请求发生时生成新的应用程序进程。
*/
private static void runSelectLoop(String abiList) throws MethodAndArgsCaller {
ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
//peers是与Zygote进程的Server Socket(mServerSocket)连接的连接列表
ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();
//将mServerSocket的文件描述符放入fds
fds.add(sServerSocket.getFileDescriptor());
peers.add(null);
//无限循环等待AMS请求Zygote进程创建新的应用程序进程
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;
}
if (i == 0) {
//AMS与Zygote进程的mServerSocket建立连接
ZygoteConnection newPeer = acceptCommandPeer(abiList);
//将这个连接添加到sdocket连接列表peer中
peers.add(newPeer);
//将该连接的socket文件描述符添加到fds中
fds.add(newPeer.getFileDesciptor());
//添加完成后就可以接受AMS发送过来的创建应用程序进程请求
} else {
//处理AMS与Zygote发送的请求
//peers.get(i)就是之前建立起来的连接(ZygoteConnection)
//调用其runOnce()来创建一个新的应用程序进程
boolean done = peers.get(i).runOnce();
if (done) {
//处理完成了这个连接，将对应的连接和描述符删除
peers.remove(i);
fds.remove(i);
}
}
}
}
}
runSelectLoop发生在启动System进程完成之后，根据代码得到Zygote进程会进入一个无限循环，不断等待AMS的连接和请求创建新的应用程序进程。针对如何通过ZygoteConnection.runOnce()来创建一个新的进程过程比较复杂，之后另开一篇文章分析；
整个过程可以用流程图简单概括：
image.png
网友评论