Android系统开机流程分析
Android系统启动分两大阶段：Linux阶段，Android阶段。
BootLoader启动，引导进入Linux内核阶段；Android启动阶段，kernel_init函数完成设备驱动程序的初始化，并调用init_post函数启动用户空间的init进程，Linux内核启动完成之后跳转到Android层init进程启动，从此开启了Android世界的大门，整个开机过程大致如下：
image.png
图A-1
从图A-1中可以看出，对于从事Android系统上层(非驱动)开发人员，理解了init进程启动之后阶段的流程便知道系统进程Systemserver， 诸如ActivityManagerService、PowerManagerService等核心服务如何启动的、怎么样进入我们常见的系统桌面(Launcher)应用的。图A-2 是init进程启动后阶段大致过程。
image.png
图A-2
Init进程启动在这里不做详细的陈述，本文主要目的是打通整个开机流程任督六脉，后续若有机会或时间，补写关于init进程启动的详细流程以及init.rc脚本的语法规则以及编写方法技巧，在此立帖为证，拜请监督。
由图A-2可知，内核初始化阶段会调用Kernel_init函数，在这个函数中调用init_post函数启动祖先进程，即init进程。
01
Init启动【1】
image.png
图A-3
文件路径：/system/core/init/init.cpp。入口函数为main，代码如下所示：
int main(int argc, char** argv) {
if (!strcmp(basename(argv[0]), "ueventd")) {
return ueventd_main(argc, argv);
}
if (!strcmp(basename(argv[0]), "watchdogd")) {
return watchdogd_main(argc, argv);
}
// Clear the umask.
umask(0);
add_environment("PATH", _PATH_DEFPATH);
bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);
// Get the basic filesystem setup we need put together in the initramdisk
// on / and then we'll let the rc file figure out the rest.
//1 创建文件并挂载
if (is_first_stage) {
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
define MAKE_STR(x) __STRING(x)
mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
mount("sysfs", "/sys", "sysfs", 0, NULL);
}
// We must have some place other than / to create the device nodes for
// kmsg and null, otherwise we won't be able to remount / read-only
// later on. Now that tmpfs is mounted on /dev, we can actually talk
// to the outside world.
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
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));
//2 初始化属性资源
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();
// Propagate the kernel variables to internal variables
// used by init as well as the current required properties.
export_kernel_boot_props();
}
...
const BuiltinFunctionMap function_map;
Action::set_function_map(&function_map);
Parser& parser = Parser::GetInstance();
parser.AddSectionParser("service",std::make_unique<ServiceParser>());
parser.AddSectionParser("on", std::make_unique<ActionParser>());
parser.AddSectionParser("import", std::make_unique<ImportParser>());
//3 解析init.rc脚本文件
parser.ParseConfig("/init.rc");
...
while (true) {
if (!waiting_for_exec) {
am.ExecuteOneCommand();
restart_processes();
}
int timeout = -1;
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (am.HasMoreCommands()) {
timeout = 0;
}
bootchart_sample(&timeout);
epoll_event ev;
int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
if (nr == -1) {
ERROR("epoll_wait failed: %s\n", strerror(errno));
} else if (nr == 1) {
((void (*)()) ev.data.ptr)();
}
}
return 0;
}
从上述代码片段可以分析可知，init进程main函数做了许多事情，但是我们只需要关注几点便可，1 is_first_stage为真时创建文件并挂载，2 调用property_init函数进行初始化属性相关资源，3 调用parser.ParseConfig("/init.rc")解析init.rc文件，至于怎么解析脚本文件在此不作阐述，如需深入理解可以跳转至system/core/init/init_parse.cpp文件进行自行阅读，这里主要介绍zygote进程是如何启动。
02
Zygote启动
讲解Zygote启动之前先准备一点预备知识，Android7.0版本的系统，Google对init.rc做了拆分，每个服务一个启动脚本，因本文是居于64Bit的Android7.0系统进行分析的，故这里拿init.zygote64.rc文件进行剖析，内容如下：
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 660 root system
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 /dev/cpuset/foreground/tasks /dev/stune/foreground/tasks
从以上脚本代码分析得知Zygote服务的class name是main。从init启动部分流程图看到main会去调用parser.ParseConfig("/init.rc")(system/core/init/init_parse.cpp)，同学们可能会有一个疑问，为什么看不到init进程去直接解析Zygote并启动？不急，且听我慢慢道来。从init.rc脚本开头处可以看到语句import /init.${ro.zygote}.rc，相当于上面的init.zygote64.rc文件中的代码内容。init.rc代码片段：
...
import /init.${ro.zygote}.rc
...
on nonencrypted
A/B update verifier that marks a successful boot.
exec - root -- /system/bin/update_verifier nonencrypted
class_start main
class_start late_start
...
根据init.rc脚本语法语义规则，class_start是一个COMMAND，它对应的函数是do_class_start,而我们从前面分析可知，main是指Zygote，所以此处是用来启动Zygote服务的。
system/core/init/builtins.cpp
static int do_class_start(const std::vector<std::string>& args) {
/* Starting a class does not start services
-
which are explicitly disabled. They must
-
be started individually.
*/
ServiceManager::GetInstance().
ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
return 0;
}
StartIfNotDisabled做了什么？
bool Service::StartIfNotDisabled() {
if (!(flags_ & SVC_DISABLED)) {
return Start(); //Service没有运行，则启动
} else {
flags_ |= SVC_DISABLED_START;
}
return true;
}
Start函数我们只需要关心两点，判断启动service的执行文件是否存在，如若不存在则不启动。否则创建子进程调用execve执行程序system/bin/app_process。
image.png
图A-4
bool Service::Start() {
...
if (flags_ & SVC_RUNNING) { //如果service已经运行，则返回
ifdef MTK_INIT
ERROR("service '%s' still running, return directly\n", name_.c_str());
endif
return false;
}
...
//判断启动service的执行文件是否存在，如若不存在则返回
struct stat sb;
if (stat(args_[0].c_str(), &sb) == -1) {
ERROR("cannot find '%s' (%s), disabling '%s'\n",
args_[0].c_str(), strerror(errno), name_.c_str());
flags_ |= SVC_DISABLED;
return false;
}
...
pid_t pid = fork();
if (pid == 0) {
umask(077);
for (const auto& ei : envvars_) {
add_environment(ei.name.c_str(), ei.value.c_str());
}
for (const auto& si : sockets_) {
int socket_type = ((si.type == "stream" ? SOCK_STREAM :
(si.type == "dgram" ? SOCK_DGRAM :
SOCK_SEQPACKET)));
const char* socketcon =
!si.socketcon.empty() ? si.socketcon.c_str() : scon.c_str();
int s = create_socket(si.name.c_str(), socket_type, si.perm,
si.uid, si.gid, socketcon);
if (s >= 0) {
PublishSocket(si.name, s);
}
}
...
if (execve(args_[0].c_str(), (char) &strs[0], (char) ENV) < 0) {
ERROR("cannot execve('%s'): %s\n", args_[0].c_str(), strerror(errno));
}
...
}
为了让读者们一目了然，根据代码流程画图A-4流图，希望能帮助理解代码执行流程。
我们进入frameworks/base/cmds/app_process/app_main.cpp文件，代码片段如下：
int main(int argc, char* const argv[])
{
...
//306行开始
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;
}
}
从上述代码可以看到，Zygote分析了那么多，辗转反侧，跋山涉水，终于看到启动Zygote的真正位置了。
找到frameworks/base/core/java/com/android/internal/os/ZygoteInit.java文件，看都做了那些事情？
public static void main(String argv[]) {
...
//判断是否需要启动SystemServer
boolean startSystemServer = false;
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)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
...
//启动SystemServer进程
if (startSystemServer) {
startSystemServer(abiList, socketName);
}
}
03
SystemServer启动
依照图A-1，main方法里面我们只需要关心SystemServer启动，其他的细枝末节暂不需要关注。SystemServer进程在整个Android世界中起着非常重要的作用。与Zygote进程一样同等重要，同属于Android的两大进程，系统很多核心进程都是在这两个进程中开启的。
既然上文说到调用startSystemServer方法启动SystemServer，那么我们来观察SystemServer类内都做了那些重要的事情？
/frameworks/base/services/java/com/android/server/SystemServer.java
image.png
图A-5
从图A-5中知道，SystemServer启动ActivityManagerService完成，在ActivityManagerService中会调用finishBooting方法完成引导过程，与此同时会发送开机的广播，当系统指定的进程接收到开机广播之后便会启动Home程序，完成Launcher桌面的加载和显示。这样Android的整个开机过程就算完成了。很明显，后面这一个过程远比我这里写的复杂得多，如果展开分析的话会导致整篇文章篇幅过长，稍有不慎就成了裹脚布又长又臭，所以这里就不作阐述了。【2】
总结
整个开机过程大分为如下几方面：
step1 BootLoader引导
step2 Kernel内核加载
step3 Init祖先进程启动
step4 Zygote进程启动
step5 SystemServer进程启动
step6 启动系统核心服务、服务库等
step7 Home桌面加载和显示
PS：后期如有时间，会详细分析init进程的启动过程，以及最后阶段是怎么一步一步启动Home桌面程序的，即文中标注【1】【2】处。
