Android系统启动流程（一）—— init进程的启动流程

最近开始阅读android系统启动模块的源码了，记录一下从中学到的东西。
文章中的源码基于android8.0.0

init进程是android在用户空间启动的第一个进程，也是用户空间其他进程的父进程，它的进程号是1，系统通过init进程来进行一些初始化工作，包括启动Zygoto、SystemServer等重要进程。

系统在加载linux内核后便会创建init进程，并会执行init文件中的main方法，接下来我们通过分析main方法的代码来看一下init进程的启动流程。

1.执行第一阶段，挂载系统运行时目录

源码路径：\system\core\init\init.cpp

int main(int argc, char** argv) {

    //  1.根据参数argv来判断是否是ueventd或watchdogd
    //strcmp函数用来比较字符串的值是否相等，相等返回0
    //basename函数用来获取字符串中最后一个‘/’之后的内容
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);
    }

    if (!strcmp(basename(argv[0]), "watchdogd")) {
        return watchdogd_main(argc, argv);
    }

    if (REBOOT_BOOTLOADER_ON_PANIC) {
        install_reboot_signal_handlers();//设置一些信号量
    }

    //添加环境变量
    add_environment("PATH", _PATH_DEFPATH);

    //  2.判断是否是第一阶段
    bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);

    if (is_first_stage) {//if内的代码只在第一阶段执行
        boot_clock::time_point start_time = boot_clock::now();

        // 清空文件权限
        umask(0);

        //   3.挂载和创建一些系统运行时必要的目录
        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));
        // Don't expose the raw commandline to unprivileged processes.
        chmod("/proc/cmdline", 0440);
        gid_t groups[] = { AID_READPROC };
        setgroups(arraysize(groups), groups);
        mount("sysfs", "/sys", "sysfs", 0, NULL);
        mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
        mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
        mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
        mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));

        //初始化log
        InitKernelLogging(argv);

        LOG(INFO) << "init first stage started!";
        
        //准备开始转入第二阶段
       ...
    }

    ...
}

在注释1处，首先通过main函数的参数argv来判断是否是ueventd或watchdogd，我们阅读源码主要是为了了解init进程的启动流程，就不对ueventd和watchdogd进行研究了。

在注释2处，通过环境变量INIT_SECOND_STAGE来判断当前是第一阶段还是第二阶段，在init进程的启动过程中，main函数一共会执行两次，分别代表第一阶段和第二阶段，如果是第一阶段，则执行if内的代码。

在注释3处，通过mount和mkdir来挂载和创建了一些系统运行时所需要的目录，这些目录只有在系统运行时才会创建，当系统关闭后这些目录都会消失。

之后便开始准备进入第二阶段。

2.转入第二阶段

        //初始化Selinux安全模块，SELinux是美国国家安全局（NSA）对于强制访问控制的实现，是 Linux的一个安全子系统
        selinux_initialize(true);

       ...

        //  1.设置环境变量，将INIT_SECOND_STAGE的值设置为true
        setenv("INIT_SECOND_STAGE", "true", 1);

        static constexpr uint32_t kNanosecondsPerMillisecond = 1e6;
        uint64_t start_ms = start_time.time_since_epoch().count() / kNanosecondsPerMillisecond;
        setenv("INIT_STARTED_AT", StringPrintf("%" PRIu64, start_ms).c_str(), 1);

        char* path = argv[0];
        char* args[] = { path, nullptr };
        //2.重新执行main方法
        execv(path, args);

在注释1处将环境变量INIT_SECOND_STAGE设置为true，然后再注释2处通过execv函数重新执行main方法，其中path的值即当前init文件的路径，execv会终止当前进程并根据path执行新的进程，但是进程id不会改变。

3.开启属性服务并初始化信号处理函数

//第二阶段重新执行main方法
int main(int argc, char** argv) {
    ...

    //由于INIT_SECOND_STAGE的值已经为true了，当第二次运行main函数时会跳过if (is_first_stage) 内的代码.
    bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);

    if (is_first_stage) {
        ...
    }

    InitKernelLogging(argv);
    LOG(INFO) << "init second stage started!";//表示现在已经处于第二阶段了

   ...

    property_init();// 1.初始化属性服务
    
    process_kernel_dt();//处理DT属性
    process_kernel_cmdline();//处理命令行属性

    export_kernel_boot_props();//处理系统属性

   ...

    // 清除不需要的环境变量
    unsetenv("INIT_SECOND_STAGE");
    unsetenv("INIT_STARTED_AT");
    unsetenv("INIT_SELINUX_TOOK");
    unsetenv("INIT_AVB_VERSION");

    // 加载Selinux
    selinux_initialize(false);
    selinux_restore_context();

    // 2.初始化信号处理函数
    signal_handler_init();

    property_load_boot_defaults();
    export_oem_lock_status();

    //开始属性服务
    start_property_service();

    set_usb_controller();
    ...

现在进入第二阶段。上面的这段代码的逻辑比较简单，主要开启了属性服务并初始化了信号处理函数。

在注释1出对属性服务进行了初始化，属性服务的作用类似于windows系统的注册表。

在注释2出初始化信号处理函数，它的主要作用是防止init进程的子进程成为僵尸进程。

在注释3出开启了属性服务。

4.解析init.rc文件

    ...
    Parser& parser = Parser::GetInstance();  // 1.获取解析器对象
    parser.AddSectionParser("service",std::make_unique());//加载解析Service语句的解析器
    parser.AddSectionParser("on", std::make_unique());//加载解析on语句的解析器
    parser.AddSectionParser("import", std::make_unique());//加载解析import语句的解析器
    std::string bootscript = GetProperty("ro.boot.init_rc", "");
    if (bootscript.empty()) {
        parser.ParseConfig("/init.rc");// 2.解析init.rc文件
        parser.set_is_system_etc_init_loaded(
                parser.ParseConfig("/system/etc/init"));
        parser.set_is_vendor_etc_init_loaded(
                parser.ParseConfig("/vendor/etc/init"));
        parser.set_is_odm_etc_init_loaded(parser.ParseConfig("/odm/etc/init"));
    } else {
        parser.ParseConfig(bootscript);
        parser.set_is_system_etc_init_loaded(true);
        parser.set_is_vendor_etc_init_loaded(true);
        parser.set_is_odm_etc_init_loaded(true);
    }

    ...

这段代码主要用来解析init.rc文件，在注释1处，通过Parser::GetInstance()获取一个Parser解析器对象，然后使用AddSectionParser方法为该对象添加了service、on和import语句的解析器。

在注释2处调用了parser的ParseConfig方法，对init.rc文件进行解析

我们先来了解一下什么是.rc文件。

4.1 .rc文件简介

.rc文件是使用android初始化语言编写的一种脚本，这种语言由许多section块组成，这些section可以分为两类：动作（Action）和服务（Service）,它们的基本形式如下：

//动作（Action）
on  [&&]*  //设置触发器，Action类型的语句为on
      //触发之后要执行的命令
    
    ...

//服务（Service）
service   []*  // <执行程序的路径> <参数>

以init.rc中的一段代码为例：

on early-init  //设置early-init触发器
   
    //下面的语句都是一些command，当early-init被触发后便执行下面的语句

    write /proc/1/oom_score_adj -1000

    # Disable sysrq from keyboard
    write /proc/sys/kernel/sysrq 0

    # Set the security context of /adb_keys if present.
    restorecon /adb_keys

    # Shouldn't be necessary, but sdcard won't start without it. http://b/22568628.
    mkdir /mnt 0775 root system

    # Set the security context of /postinstall if present.
    restorecon /postinstall

    start ueventd

在.rc文件中还有一类import语句，用来引入其他.rc文件。

4.2init.rc源码分析

我们来看一下init.rc文件的源码：
源码路径：\system\core\rootdir\init.rc

import /init.environ.rc
import /init.usb.rc
import /init.${ro.hardware}.rc
import /vendor/etc/init/hw/init.${ro.hardware}.rc
import /init.usb.configfs.rc
import /init.${ro.zygote}.rc  //  1.加载init.zygote.rc文件

//下面是一系列的触发器

on early-init
   
    write /proc/1/oom_score_adj -1000

    write /proc/sys/kernel/sysrq 0

    restorecon /adb_keys

    mkdir /mnt 0775 root system

    restorecon /postinstall

    start ueventd

on init
    sysclktz 0

    copy /proc/cmdline /dev/urandom
    copy /default.prop /dev/urandom

    symlink /system/etc /etc
    symlink /sys/kernel/debug /d

    symlink /system/vendor /vendor

    mount cgroup none /acct cpuacct
    mkdir /acct/uid
    ... 

on late-init
    trigger early-fs

    trigger fs
    trigger post-fs

    trigger late-fs

    trigger post-fs-data

    trigger zygote-start  // 2.触发zygote-start

    trigger load_persist_props_action

    trigger firmware_mounts_complete

    trigger early-boot
    trigger boot
    ...

on zygote-start && property:ro.crypto.state=unencrypted
    exec_start update_verifier_nonencrypted
    start netd
    start zygote  //3.启动zygote
    start zygote_secondary

...
...

在注释1处使用import语句引入了init.zygote.rc文件，这是后面启动zygote进程的关键一步，可以看到init.zygote.rc文件的名字是不固定的，那是因为根据手机处理器位数的不通，将init.zygote.rc拆分成了多个不同的文件，如init.zygote32.rc、init.zygote64.rc等。

然后通过on语句定义了一系列的触发器，包括early-init、init等等。

可以看到在late-init被触发时会去触发zygote-start这个触发器（注释2处），而在zygote-start中则会调用start zygote(注释3处)，我们来看一下init.zygote32.rc文件的源码：
源码位置：\system\core\rootdir\init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    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
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

可以看到，该文件通过service语句来创建zygote进程，该进程的代码位于/system/bin/app_process目录下。

这样，当相关的触发器被触发后，便会启动zygote进程。

4.3 init.rc文件的解析流程

回到init.cpp的main方法中来，前面我们说过parser对象调用AddSectionParser方法为该对象添加了service、on和import语句的解析器，并使用ParseConfig方法对init.rc文件进行解析，我们来看一下这两个方法的源码：

文件路径：\system\core\init\init_parser.cpp

void Parser::AddSectionParser(const std::string& name, std::unique_ptr parser) {
    section_parsers_[name] = std::move(parser);
}

section_parsers_有点类似于java中的map对象，AddSectionParser方法就是将一个触发器对象放到了一个map集合中。

bool Parser::ParseConfig(const std::string& path) {
    if (is_dir(path.c_str())) {  // 1.判断是否目录
        return ParseConfigDir(path);
    }
    return ParseConfigFile(path);
}

bool Parser::ParseConfigFile(const std::string& path) {
    ...
    std::string data;
    if (!read_file(path, &data)) {  // 2.将要解析的文件的数据读入到data中
        return false;
    }
    ...
    ParseData(path, data);  //3.调用ParseData方法进行解析
    ...
}

在ParseConfig方法中，首先判断传入的文件是否是一个目录，如果是目录则调用ParseConfigDir方法，如果是文件则调用ParseConfigFile方法，由于我们需要解析的init.rc是一个文件，我们直接来看ParseConfigFile方法。

在注释2出，将要解析的文件的数据读取到了一个string类型的变量data中，然后再注释3处调用ParseData方法进行数据解析。

我们来看ParseData方法的源码：

void Parser::ParseData(const std::string& filename, const std::string& data) {
    
    std::vector data_copy(data.begin(), data.end());// 1.将数据存入一个char类型的链表中
    data_copy.push_back('\0');//在结尾添加‘\0’作为结束标示

    parse_state state;   // 创建一个state对象
    state.filename = filename.c_str();
    state.line = 0;
    state.ptr = &data_copy[0];  //state对象内的ptr指针指向data_copy链表
    state.nexttoken = 0;

    SectionParser* section_parser = nullptr;//section解析器
    std::vector args;

    for (;;) {
        switch (next_token(&state)) {  
        case T_EOF:  //当读取到结束标示符时
            if (section_parser) {
                section_parser->EndSection();  //1.调用EndSection
            }
            return;
        case T_NEWLINE:  //读取到回车符时
            ...
            //section_parsers_是一个map，之前我们创建的on service import语句解析器便放入了这个map中
            if (section_parsers_.count(args[0])) {//2.如果args[0]是on、service、import语句
                ...
                if (!section_parser->ParseSection(args, &ret_err)) {//调用ParseSection进行解析
                    ...
                }
            } else if (section_parser) {
                ...
                if (!section_parser->ParseLineSection(args, state.filename, state.line, &ret_err)) {//调用ParseLineSection
                    ...
                }
            }
            args.clear();  //清空
            break;
        case T_TEXT:  
            args.emplace_back(state.text);  //3.将读入的数据放入args中
            break;
        }
    }
}

在ParseData函数中开启了一个无限循环来进行数据的读取，当读取到一个单词时，便将这个单词放到一个字符串链表args中（注释3处），这样便将一行语句拆分成了多个单词。

在注释2处，通过args[0]来从section_parsers_这个map中获取解析器，在第4节我们创建了on、service、import类型的解析器并放入到了这个map中，因此如果args[0]是这三种语句中的一种便可以获取到相应的解析器，否则的话这条语句可能是一条command或option。然后分别调用ParseSection或ParseLineSection方法来进行解析。

当读取到结束符号时，则调用EndSection方法（注释1处）。

ParseSection方法是一个抽象方法，在各个解析器中的实现不同，我们主要来看一下ServiceParser中的实现：
源码位置：\system\core\init\service.cpp

bool ServiceParser::ParseSection(const std::vector& args,
                                 std::string* err) {
   ...
    service_ = std::make_unique(name, str_args);//1.生成service_对象
    return true;
}

从源码中我们可以看到，ParseSection主要是根据传入的service语句来构建了一个service_对象。

我们再来看一下EndSection方法在ServiceParser中的实现：

void ServiceParser::EndSection() {
    if (service_) {
        ServiceManager::GetInstance().AddService(std::move(service_));
    }
}

该方法即使是service_对象存入到了ServiceManager中。

ActionParser中的ParseSection方法与ServiceParser类似，只是ActionParser是根据action语句创建了一个action_对象，并把这个action_放入了ActionManager中。

至此init.rc中的各类Action和Service便都加载完成了。

5.将需要被触发的触发器加入队列

我们回到init.cpp的main方法中继续往下看：

    ActionManager& am = ActionManager::GetInstance();

    am.QueueEventTrigger("early-init");  //early-init触发器

    am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
    am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
    am.QueueBuiltinAction(set_mmap_rnd_bits_action, "set_mmap_rnd_bits");
    am.QueueBuiltinAction(set_kptr_restrict_action, "set_kptr_restrict");
    am.QueueBuiltinAction(keychord_init_action, "keychord_init");
    am.QueueBuiltinAction(console_init_action, "console_init");
    am.QueueEventTrigger("init");  //init触发器

    am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");

    std::string bootmode = GetProperty("ro.bootmode", "");
    if (bootmode == "charger") {
        am.QueueEventTrigger("charger");
    } else {
        am.QueueEventTrigger("late-init");  //late-init触发器
    }
    am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");

在解析完init.rc文件之后，我们还要进行一些准备工作才能对各类事件进行触发。在上面的代码中，我们先获取了ActionManager的实例，然后通过QueueEventTrigger方法将需要被触发的触发器加入到了触发队列中，并使用QueueBuiltinAction方法用于动态创建了一些Action。可以看到early-init、init、late-init触发器都先后被加入到了队列中。

QueueEventTrigger的源码如下：
源码路径：\system\core\init\action.cpp

//std::queue> trigger_queue_;定义于.h中
void ActionManager::QueueEventTrigger(const std::string& trigger) {
    trigger_queue_.push(std::make_unique(trigger));//将触发器加入到队列中
}

6.触发事件，并不断监听新事件

   while (true) {
        ...
        if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
            am.ExecuteOneCommand();  //执行一条command
        }
        if (!(waiting_for_prop || ServiceManager::GetInstance().IsWaitingForExec())) {
            restart_processes();  //重启需要重启的进程
            ...
        }
        ...
    }

通过while(true)开启了一个事件循环模型，在这个无限循环中，通过ActionManager的ExecuteOneCommand来逐条执行Action的command。

至此init进程的启动便完成了。

7.总结

总结一下init进程启动所做的事情：
1.挂载和创建系统目录
2.初始化系统log、开启属性服务、加载Selinux模块等工作
3.解析init.rc文件，加载各种Action和Service
4.触发Action，并不断监听新的Action

参考资料：
https://www.jianshu.com/p/befff3d70309
https://www.jianshu.com/p/464c3d1203b1
《Android》进阶解密——刘望舒著