Android 8.1 init 进程解析 rc 文件与启动服务全流程剖析

4 阅读8分钟

1. 引言

在 Android 系统中,init 进程是用户空间的第一个进程(PID 为 1),由内核在启动阶段直接拉起。它承担着解析启动脚本、创建系统目录、挂载文件系统、启动各类系统服务、处理属性变更等核心职责。

Android 8.1(Oreo MR1)是 Android 版本演进中一个重要的分水岭:从 8.0 开始,Google 引入了 Treble 架构,把 init 拆分为 first stage 与 second stage 两个阶段,同时把 rc 文件的解析逻辑重构为基于 Parser 类的模块化实现。理解这一版本的 init 工作流程,对排查开机问题、定制系统服务、分析启动耗时都很有价值。

本文以 Android 8.1 源码(system/core/init)为基础,从内核启动 init 开始,逐步拆解 rc 文件的读取、解析、服务注册与启动的完整链路。

2. init 进程的启动入口

2.1 内核如何拉起 init

内核在完成自身初始化后,会尝试执行 /init、/sbin/init 等路径。Android 的 init 二进制位于 system/core/init,编译后安装到根目录 /init。

init 的入口函数在 init.cpp 中:

int main(int argc, char** argv) {
    // 判断是否为 first stage
    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) {
        InstallRebootSignalHandlers();
    }

    boot_clock::time_point start_time = boot_clock::now();

    // 清空 umask,保证后续创建文件权限可控
    umask(0);

    // 挂载 /proc /sys 等基础文件系统
    mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
    mkdir("/dev/pts", 0755);
    mkdir("/dev/socket", 0755);
    mount("devpts", "/dev/pts", "devpts", 0, NULL);
    mount("proc", "/proc", "proc", 0, NULL);
    mount("sysfs", "/sys", "sysfs", 0, NULL);

    // 关键:判断是否需要进入 first stage
    if (!is_first_stage) {
        // 第二阶段:重新打开 /dev/kmsg 等
        ...
    }

    // 初始化属性系统
    property_init();

    // 解析 first stage 的 rc 文件
    ...
}

2.2 first stage 与 second stage 的划分

Android 8.1 中,init 通过 is_first_stage 标志区分两个阶段:

  • first stage:运行在 ramdisk 中,主要完成挂载 system、vendor 分区,创建 /dev 下的设备节点,加载 SELinux 策略等最基础的工作。
  • second stage:在 system 分区挂载完成后,重新执行 init(通过 execv),此时会完整解析所有 rc 文件并启动服务。

判断逻辑大致如下:

// 如果 /system 已经挂载,说明是 second stage
static bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);

在 first stage 结束时,会设置环境变量并重新执行自身:

if (is_first_stage) {
    // 挂载 system、vendor 分区
    if (mount("system", "/system", "ext4", ...) != 0) {
        ...
    }
    // 设置标志,重新执行 init 进入 second stage
    setenv("INIT_SECOND_STAGE", "true", 1);
    execv("/system/bin/init", argv);
}

3. rc 文件的组织与加载顺序

3.1 rc 文件的位置

Android 8.1 的 rc 文件分布在多个分区,init 会按固定顺序加载:

顺序路径说明
1/init.rc根目录主脚本,由 ramdisk 提供
2/init.${ro.hardware}.rc硬件相关脚本
3/vendor/etc/init/hw/init.${ro.hardware}.rcvendor 硬件脚本
4/system/etc/init/*.rcsystem 分区下的模块化脚本
5/vendor/etc/init/*.rcvendor 分区下的模块化脚本
6/odm/etc/init/*.rcodm 分区脚本(如有)

其中 /system/etc/init/ 和 /vendor/etc/init/ 目录下的 rc 文件是 Treble 架构引入的模块化配置,每个服务或 HAL 可以自带一个 rc 文件,避免全部堆在 init.rc 中。

3.2 加载入口

在 init.cpp 的 second stage 中,会调用 LoadBootScripts:

static void LoadBootScripts(ActionManager& action_manager, ServiceManager& service_manager) {
    Parser parser = CreateParser(action_manager, service_manager);

    std::string bootscript = GetProperty("ro.boot.init_rc", "");
    if (bootscript.empty()) {
        // 加载 /init.rc
        parser.ParseConfig("/init.rc");
        // 加载 /system/etc/init 等目录
        parser.ParseConfig("/system/etc/init");
        parser.ParseConfig("/vendor/etc/init");
        parser.ParseConfig("/odm/etc/init");
    } else {
        parser.ParseConfig(bootscript);
    }
}

CreateParser 会注册所有支持的关键字(如 service、on、import、setprop 等),后续解析时按关键字分发到对应的处理函数。

4. rc 文件的解析流程

4.1 Parser 类的结构

Android 8.1 的解析核心是 Parser 类(init/parser.h),它维护了两张表:

class Parser {
public:
    static Parser& GetInstance();
    void AddSectionParser(const std::string& name,
                          std::unique_ptr<SectionParser> parser);
    void AddSingleLineParser(const std::string& prefix,
                             const std::function<void(const std::string&)>& callback);
    bool ParseConfig(const std::string& path);
    ...
private:
    std::map<std::string, std::unique_ptr<SectionParser>> section_parsers_;
    std::map<std::string, std::function<void(const std::string&)>> line_parsers_;
};
  • section_parsers_:处理「段」类型的关键字,如 service、on、import。
  • line_parsers_:处理单行关键字,如 setprop、write、copy。

4.2 逐行读取与状态机

ParseConfig 会打开文件,逐行读取并交给 ParseData 处理:

bool Parser::ParseConfig(const std::string& path) {
    if (is_dir(path.c_str())) {
        return ParseConfigDir(path);
    }
    return ParseConfigFile(path);
}

bool Parser::ParseConfigFile(const std::string& path) {
    std::string data;
    if (!ReadFileToString(path, &data)) {
        return false;
    }
    ParseData(path, data);
    return true;
}

void Parser::ParseData(const std::string& filename, const std::string& data) {
    std::vector<std::string> args;
    parse_state state;
    state.line = 0;
    state.ptr = data.c_str();
    state.nexttoken = 0;
    state.parse_line = ParseLineSection;  // 初始状态:解析段头

    SectionParser* section_parser = nullptr;
    for (;;) {
        switch (state.parse_line(&state, nullptr)) {
            case kParseLineSection:
                // 遇到 service/on 等段头,创建对应 SectionParser
                section_parser = ...;
                break;
            case kParseLineSectionEnd:
                // 段结束,调用 EndSection
                section_parser->EndSection();
                break;
            case kParseLineArgs:
                // 段内参数行
                section_parser->ParseLineSection(args, filename, state.line);
                break;
        }
    }
}

这里的关键是 parse_state 状态机,它把每一行拆成 token(参数),并根据当前是否处于某个段内,决定交给 SectionParser 还是单行解析器。

4.3 段解析器:ServiceParser 与 ActionParser

以 service 段为例,ServiceParser 负责把一段 service 配置转换成 Service 对象:

class ServiceParser : public SectionParser {
public:
    ServiceParser(ServiceManager* service_manager)
        : service_manager_(service_manager) {}

    bool ParseSection(const std::vector<std::string>& args,
                      const std::string& filename, int line) override {
        if (args.size() < 3) {
            return false;
        }
        // args[1] 是服务名,args[2] 是可执行文件路径
        service_ = std::make_unique<Service>(args[1], args[2]);
        return true;
    }

    void ParseLineSection(const std::vector<std::string>& args,
                          const std::string& filename, int line) override {
        // 处理 class、user、group、oneshot、socket 等选项
        service_->ParseLineSection(args, filename, line);
    }

    void EndSection() override {
        // 段结束,把服务注册到 ServiceManager
        service_manager_->AddService(std::move(service_));
    }
};

ActionParser 则处理 on 段,把触发条件(如 boot、property:xxx=yyy)和命令列表封装成 Action 对象,注册到 ActionManager。

5. 服务的注册与启动

5.1 Service 对象的关键字段

解析完成后,每个服务对应一个 Service 对象,核心字段包括:

class Service {
    std::string name_;          // 服务名
    std::string prog_;          // 可执行文件路径
    std::vector<std::string> args_;  // 启动参数
    bool oneshot_;              // 是否只运行一次
    bool disabled_;             // 是否默认禁用
    std::string classname_;     // 服务类别,如 core、main
    uid_t uid_;                 // 运行用户
    gid_t gid_;                 // 运行用户组
    std::vector<SocketInfo> sockets_;  // 关联的 socket
    ...
};

5.2 服务何时被启动

服务本身不会在解析时立即启动,而是由 Action 触发。init.rc 中通常有:

on boot
    class_start core
    class_start main

class_start 命令会遍历 ServiceManager 中所有属于该类别的服务,逐个调用 Start():

int ServiceManager::StartServicesByClass(const std::string& class_name) {
    for (auto& service : services_) {
        if (service->classname() == class_name) {
            service->Start();
        }
    }
    return 0;
}

5.3 Service::Start 的内部实现

Start() 是服务启动的核心,主要步骤包括:

bool Service::Start() {
    // 1. 检查是否已运行
    if (pid_ != 0) {
        return true;
    }

    // 2. 创建 socket(如果配置了 socket 选项)
    for (const auto& socket : sockets_) {
        if (!socket.Create()) {
            return false;
        }
    }

    // 3. fork 子进程
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程:设置 uid/gid、SELinux 上下文、环境变量
        setuid(uid_);
        setgid(gid_);
        setexeccon(seclabel_.c_str());
        // 执行可执行文件
        execve(prog_.c_str(), args, env);
        _exit(127);
    }

    // 4. 父进程记录 pid
    pid_ = pid;
    return true;
}

关键点:

  • fork + execve:服务是 init 的子进程,通过 fork 创建后 execve 执行目标程序。
  • 权限切换:在子进程中通过 setuid/setgid 切换到配置的用户。
  • SELinux:通过 setexeccon 设置进程的 SELinux 上下文,这是 Android 8.1 安全模型的重要一环。
  • oneshot 服务:如果 oneshot_ 为 true,服务退出后不会被重启。

5.4 服务重启与状态管理

init 通过 SIGCHLD 信号感知子进程退出。在 signal_handler.cpp 中:

static void SIGCHLD_handler(int) {
    // 写入 self-pipe,唤醒主循环
    ...
}

主循环 epoll 收到事件后调用 ReapAnyOutstandingChildren(),遍历已退出的子进程,根据服务配置决定是否重启:

void ServiceManager::ReapOneProcess() {
    ...
    if (service->oneshot()) {
        service->SetState(STOPPED);
    } else {
        service->Restart();  // 非 oneshot 服务自动重启
    }
}

6. 完整启动时序图

下面用一张时序图串联整个流程:

sequenceDiagram
    participant K as &#34;内核&#34;
    participant I1 as &#34;init(first stage)&#34;
    participant I2 as &#34;init(second stage)&#34;
    participant P as &#34;Parser&#34;
    participant SM as &#34;ServiceManager&#34;
    participant AM as &#34;ActionManager&#34;
    participant S as &#34;Service子进程&#34;

    K->>I1: &#34;execve(/init)&#34;
    I1->>I1: &#34;挂载 /system /vendor&#34;
    I1->>I2: &#34;setenv + execv 重新执行&#34;
    I2->>P: &#34;LoadBootScripts()&#34;
    P->>P: &#34;ParseConfig(/init.rc)&#34;
    P->>P: &#34;ParseConfig(/system/etc/init)&#34;
    P->>SM: &#34;AddService(Service)&#34;
    P->>AM: &#34;AddAction(Action)&#34;
    I2->>AM: &#34;QueueEventTrigger(boot)&#34;
    AM->>SM: &#34;class_start core/main&#34;
    SM->>S: &#34;fork + execve&#34;
    S-->>I2: &#34;SIGCHLD 退出通知&#34;
    I2->>SM: &#34;ReapOneProcess()&#34;
    SM->>S: &#34;Restart() 非 oneshot 服务&#34;

7. 常见问题与调试技巧

7.1 如何确认某个服务是否被解析

可以在 init.rc 中临时加入:

on boot
    write /dev/kmsg "my_service parsed"

或者通过 getprop 查看服务状态。更直接的方式是查看 init 日志:

adb logcat -b events | grep init
adb shell dmesg | grep init

7.2 服务启动失败排查

常见原因:

  • 可执行文件不存在:检查 prog_ 路径是否正确,/system/bin 下是否有该文件。
  • SELinux 拒绝:查看 dmesg 中的 avc: denied 日志,补充对应的 sepolicy 规则。
  • 权限不足:检查 user/group 配置是否与文件权限匹配。
  • 依赖服务未启动:使用 on property:xxx=yyy 或 wait_for_prop 控制启动顺序。

7.3 查看 rc 文件解析结果

Android 8.1 提供了 init 的调试命令:

# 查看所有已注册服务
adb shell getprop | grep init.svc

# 查看某个服务状态
adb shell getprop init.svc.zygote

init.svc.<name> 属性会实时反映服务状态(running、stopped、restarting)。

8. 总结

Android 8.1 的 init 进程在 rc 文件解析与服务启动上形成了清晰的链路:

  1. 两阶段启动:first stage 完成基础挂载,second stage 完整解析 rc 并启动服务。
  2. 模块化 rc 文件:/system/etc/init、/vendor/etc/init 目录让服务配置解耦。
  3. Parser 状态机:通过 SectionParser 与单行解析器,把 rc 文本转换为 Service 与 Action 对象。
  4. Action 驱动启动:服务由 on boot 等触发器通过 class_start 拉起,fork + execve 完成进程创建。
  5. SIGCHLD 回收与重启:非 oneshot 服务退出后自动重启,保证系统稳定性。

掌握这条链路后,无论是定制系统服务、排查开机卡死,还是分析启动耗时,都能快速定位到对应的代码位置。