Android系统启动系列

1. Android系统启动系列----init进程
2. Android系统启动系列----Zygote进程

引言

在开发app的过程中，是不是会有疑问：

• java程序的运行不是从main方法开始么，怎么app入口是Application的onCreate方法？
• 那java的运行环境虚拟机Dalvik VM和ART又是什么时候创建的？又是由谁创建的？
• 安卓是Linux内核，那内核创建后系统又做了什么初始化了整个安卓环境？
• 当我们的手机或者安卓系统设备按下电源按键的时候，系统都做什么？

当按下电源的那一刻都发生了啥：

今天的分析都是基于Android 6.0系统的分析。

第一步：启动电源

当电源按下，引导芯片代码开始从预定义的地方（固化在ROM）开始执行。加载引导程序到RAM，然后执行。

第二步：执行引导程序（Boot Loader）

通常在运行Android系统之前会先执行Boot Loader引导程序，它不属于Android系统，常见的引导程序有：redboot、uboot、qi bootloader等等。或者自行开发引导程序，它是针对特定主板和芯片的，OEM制造厂商或者运营商在加锁的时候就对这个引导程序做修改，比如魅族就是修改了引导程序，所以刷不了机。

第三步：内核

Android内核与桌面linux内核启动的方式差不多。内核启动时，设置缓存、被保护存储器、计划列表，加载驱动。当内核完成系统设置，它首先在系统文件中寻找”init”文件，然后启动root进程或者系统的第一个进程。

第四步：执行init进程

init进程是Android系统启动的第一个用户空间进程，init进程主要做两个事情。第一：挂载目录，如：挂载了/sys /dev /proc 等目录。第二：解析执行init.rc脚本文件。

系统编译，刷入手机后，init的进程保存在/system/core/bin目录中，对应程序的源代码入口是/system/core/init/init.cpp。

int main(int argc, char** argv) {if (!is_first_stage) {// Indicate that booting is in progress to background fw loaders, etc.close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));// 初始化属性服务property_init();// If arguments are passed both on the command line and in DT,// properties set in DT always have priority over the command-line ones.process_kernel_dt();process_kernel_cmdline();// Propogate the kernel variables to internal variables// used by init as well as the current required properties.export_kernel_boot_props();}........//  开始属性服务start_property_service();// 初始化“init.rc”配置文件解析器init_parse_config_file("/init.rc");action_for_each_trigger("early-init", action_add_queue_tail);........
}
复制代码

主要看init.rc脚本文件的解析，在说解析前，先来了解下配置脚本的内容，这是一个内建的脚本语言也叫Android初始化语言，有自己的语法结构，大概介绍下： Android初始化语言由四大类型的声明组成，即Actions（动作）、Commands（命令）、Services（服务）、以及Options（选项）。 Action（动作）：动作是以命令流程命名的，有一个触发器决定动作是否发生。

on early-init# Set init and its forked children's oom_adj.write /proc/1/oom_score_adj -1000# Set the security context of /adb_keys if present.restorecon /adb_keysstart ueventdon initsysclktz 0# Backward compatibility.symlink /system/etc /etcsymlink /sys/kernel/debug /d# Link /vendor to /system/vendor for devices without a vendor partition.symlink /system/vendor /vendor# Create cgroup mount point for cpu accountingmkdir /acctmount cgroup none /acct cpuacctmkdir /acct/uid
复制代码

以上脚本中，on early-init、on init就是 Action类型的语句，语法格式为：

on <trigger> [&& <trigger>]*     //设置触发器  <command>  <command>      //动作触发之后要执行的命令
复制代码

Service（服务）：服务是init进程启动的程序、当服务退出时init进程会视情况重启服务，语法格式为：

 service <name> <pathname> [ <argument> ]*   //<service的名字><执行程序路径><传递参数>  <option>       //option是service的修饰词，影响什么时候、如何启动services  <option>  ...
复制代码

下面是默认的init.rc文件，主要的事件及其服务。

通常在这个阶段，我们可以在屏幕上看到“Android logo”字样或者图标。

我们重点来看看zygote进程相关的属性配置，它是独立的一个rc文件在/system/core/rootdir/init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-serverclass mainsocket zygote stream 660 root systemonrestart write /sys/android_power/request_state wakeonrestart write /sys/power/state ononrestart restart mediaonrestart restart netdwritepid /dev/cpuset/foreground/tasks
复制代码

执行zygote程序，其实是通过执行app_process程序，然后传入xzygote等等参数实现的。先找到app_process程序的源码所在地：/frameworks/base/cmds/app_process/app_main.cpp 直接看程序的main函数：

int main(int argc, char* const argv[])
{if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {// Older kernels don't understand PR_SET_NO_NEW_PRIVS and return// EINVAL. Don't die on such kernels.if (errno != EINVAL) {LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));return 12;}}AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));// Process command line arguments// ignore argv[0]argc--;argv++;int i;for (i = 0; i < argc; i++) {if (argv[i][0] != '-') {break;}if (argv[i][1] == '-' && argv[i][2] == 0) {++i; // Skip --.break;}runtime.addOption(strdup(argv[i]));}// Parse runtime arguments.  Stop at first unrecognized option.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;}}Vector<String8> args;if (!className.isEmpty()) {args.add(application ? String8("application") : String8("tool"));runtime.setClassNameAndArgs(className, argc - i, argv + i);} else {// We're in zygote mode.maybeCreateDalvikCache();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(niceName.string());set_process_name(niceName.string());}// 如果参数是--zygote，那么runtime.start执行zygote进程if (zygote) {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;}
}
复制代码

上面就是通过app_process进程，启动zygote进程的入口，执行启动zygote的程序的在java层的/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java，接下来我们看看：runtime.start("com.android.internal.os.ZygoteInit", args, zygote)都干了啥。 runtime是AppRuntime类的对象，start函数在其父类AndroidRuntime中声明和实现。AndroidRuntime是不是很熟悉了，Android的运行时，通常app异常的时候这玩意是不是总伴随你左右。原来这玩意这么早就启动在监控系统的一举一动了。

/** Start the Android runtime.  This involves starting the virtual machine* and calling the "static void main(String[] args)" method in the class* named by "className".** Passes the main function two arguments, the class name and the specified* options string.*/
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{....../* start the virtual machine */JniInvocation jni_invocation;jni_invocation.Init(NULL);JNIEnv* env;if (startVm(&mJavaVM, &env, zygote) != 0) {  // 1return;}onVmCreated(env);   // 2/** Register android functions.*/if (startReg(env) < 0) {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);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);jclass startClass = env->FindClass(slashClassName);  // 3if (startClass == NULL) {ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);/* keep going */} else {jmethodID startMeth = env->GetStaticMethodID(startClass, "main","([Ljava/lang/String;)V");  // 4if (startMeth == NULL) {ALOGE("JavaVM unable to find main() in '%s'\n", className);/* keep going */} else {env->CallStaticVoidMethod(startClass, startMeth, strArray);  // 5#if 0if (env->ExceptionCheck())threadExitUncaughtException(env);
#endif}}......
}
复制代码

1. 注释1：startVm顾名思义启动虚拟机，在此启动java虚拟机，当然这个是运行zygote进程的虚拟机，也就回答了文章最开始引言问题，虚拟机由app_process的AndroidRuntime创建。
2. 注释2：虚拟机创建后的回调处理，主要是创建一些资源。
3. 注释3：className就是app_process中传入的参数“com.android.internal.os.ZygoteInit”，因为ZygoteInit是java层的，所以需要使用jni来找到ZygoteInit.class，startClass就是ZygoteInit.class
4. 注释4：通过jni的GetStaticMethodID函数获取到ZygoteInit.java的静态main方法的类似于反射的Mehod对象引用。
5. 注释5：最后通过JNI的CallStaticVoidMethod函数类似于java反射的invoke方法，调用了4中获取的main方法的Method引用。 （如果对JNI不熟的可以看看JNI系列入门文章）

如上就是Zygote进程的启动方式。

总结

1. 手机按下电源后，加载引导程序到内存中。
2. 执行引导程序
3. 启动内核，设置缓存、被保护存储器、计划列表，加载驱动，查找/system/core/bin中init程序文件。
4. 启动init程序，挂载/sys /dev /proc等等目录，加载和解析init.rc脚本。
5. 在加载init.rc脚本的时候，启动app_process进程。
6. 在app_process进程中，根据init.zygote32.rc脚本配置的参数，启动zygote进程。
7. 最终zygote进程的执行，即ZygoteInit.java文件main方法的执行，是由AndroidRuntime通过JNI的方式调用main方法执行的。在这之前启动了Dalvik VM或者ART虚拟机。

Android系统启动系列

1. Android系统启动系列----init进程
2. Android系统启动系列----Zygote进程