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}.rc | vendor 硬件脚本 |
| 4 | /system/etc/init/*.rc | system 分区下的模块化脚本 |
| 5 | /vendor/etc/init/*.rc | vendor 分区下的模块化脚本 |
| 6 | /odm/etc/init/*.rc | odm 分区脚本(如有) |
其中 /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 "内核"
participant I1 as "init(first stage)"
participant I2 as "init(second stage)"
participant P as "Parser"
participant SM as "ServiceManager"
participant AM as "ActionManager"
participant S as "Service子进程"
K->>I1: "execve(/init)"
I1->>I1: "挂载 /system /vendor"
I1->>I2: "setenv + execv 重新执行"
I2->>P: "LoadBootScripts()"
P->>P: "ParseConfig(/init.rc)"
P->>P: "ParseConfig(/system/etc/init)"
P->>SM: "AddService(Service)"
P->>AM: "AddAction(Action)"
I2->>AM: "QueueEventTrigger(boot)"
AM->>SM: "class_start core/main"
SM->>S: "fork + execve"
S-->>I2: "SIGCHLD 退出通知"
I2->>SM: "ReapOneProcess()"
SM->>S: "Restart() 非 oneshot 服务"
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 文件解析与服务启动上形成了清晰的链路:
- 两阶段启动:first stage 完成基础挂载,second stage 完整解析 rc 并启动服务。
- 模块化 rc 文件:
/system/etc/init、/vendor/etc/init目录让服务配置解耦。 - Parser 状态机:通过
SectionParser与单行解析器,把 rc 文本转换为Service与Action对象。 - Action 驱动启动:服务由
on boot等触发器通过class_start拉起,fork + execve完成进程创建。 - SIGCHLD 回收与重启:非 oneshot 服务退出后自动重启,保证系统稳定性。
掌握这条链路后,无论是定制系统服务、排查开机卡死,还是分析启动耗时,都能快速定位到对应的代码位置。