本文基于 Android 14.0.0_r2 的系统启动流程分析。

一、概述

init 进程属于一个守护进程，准确的说，它是 Linux 系统中用户控制的第一个进程，它的进程号为 1，它的生命周期贯穿整个 Linux 内核运行的始终。Android 中所有其它的进程共同的鼻祖均为 init 进程。

可以通过 adb shell ps | grep init 命令来查看 init 的进程号：

wutianhao@wutianhao-Ubuntu:~$ adb shell ps | grep init
root             1     0 10858080   932 0                   0 S init

二、init 进程入口

init 入口函数是 main.cpp，它把各个阶段的操作分离开来，使代码更加简洁：

/system/core/init/main.cppint main(int argc, char** argv) {...// 设置进程最高优先级 -20最高，20最低setpriority(PRIO_PROCESS, 0, -20);// 当 argv[0] 的内容为 ueventd 时，strcmp的值为 0,!strcmp 为 1；// 1 表示 true，也就执行 ueventd_main；// ueventd 主要是负责设备节点的创建、权限设定等一些列工作。if (!strcmp(basename(argv[0]), "ueventd")) {return ueventd_main(argc, argv);}if (argc > 1) {// 参数为 subcontext，初始化日志系统。if (!strcmp(argv[1], "subcontext")) {android::base::InitLogging(argv, &android::base::KernelLogger);const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();return SubcontextMain(argc, argv, &function_map);}// 参数为 selinux_setup，启动 SELinux 安全策略if (!strcmp(argv[1], "selinux_setup")) {return SetupSelinux(argv);}// 参数为 second_stage，启动 init 进程第二阶段if (!strcmp(argv[1], "second_stage")) {return SecondStageMain(argc, argv);}}// 默认启动 init 进程第一阶段return FirstStageMain(argc, argv);
}

main 函数有四个参数入口：

• 参数中有 ueventd，进入 ueventd_main。
• 参数中有 subcontext，进入 InitLogging 和 SubcontextMain。
• 参数中有 selinux_setup，进入 SetupSelinux。
• 参数中有 second_stage，进入 SecondStageMain。

main 函数的执行顺序：

1. ueventd_main：init 进程创建子进程 ueventd，并将创建设备节点文件的工作托付给 ueventd，ueventd 通过两种方式创建设备节点文件。
2. FirstStageMain：启动第一阶段。
3. SetupSelinux：加载 selinux 规则，并设置 selinux 日志,完成 SELinux 相关工作。
4. SecondStageMain：启动第二阶段。

三、ueventd_main

ueventd_main 函数是 Android 系统中 ueventd 服务的主入口函数，负责处理和响应来自 Linux 内核的 uevents（设备事件）。

源码路径：/system/core/init/ueventd.cpp

1. 初始化

   int ueventd_main(int argc, char** argv) {umask(000);android::base::InitLogging(argv, &android::base::KernelLogger);...
   }
   

   • 首先调用 umask(000) 来设置进程创建文件时不受 umask 影响，确保新创建的文件具有指定的精确权限。
   • 接着初始化日志系统以便记录相关信息。

2. SELinux 设置

   int ueventd_main(int argc, char** argv) {...SelinuxSetupKernelLogging();SelabelInitialize();...
   }
   

   • 调用 SelinuxSetupKernelLogging() 和 SelabelInitialize() 函数来配置 SELinux 相关的日志以及标签库初始化。

3. 创建 UeventHandler 对象

   int ueventd_main(int argc, char** argv) {...std::vector<std::unique_ptr<UeventHandler>> uevent_handlers;auto ueventd_configuration = GetConfiguration();uevent_handlers.emplace_back(std::make_unique<DeviceHandler>(std::move(ueventd_configuration.dev_permissions),std::move(ueventd_configuration.sysfs_permissions),std::move(ueventd_configuration.subsystems), android::fs_mgr::GetBootDevices(), true));uevent_handlers.emplace_back(std::make_unique<FirmwareHandler>(std::move(ueventd_configuration.firmware_directories),std::move(ueventd_configuration.external_firmware_handlers)));if (ueventd_configuration.enable_modalias_handling) {std::vector<std::string> base_paths = {"/odm/lib/modules", "/vendor/lib/modules"};uevent_handlers.emplace_back(std::make_unique<ModaliasHandler>(base_paths));}...
   }
   

   • 根据获取到的配置信息，创建并存储多个不同类型的 UeventHandler 子类实例，如 DeviceHandler、FirmwareHandler 和可能的 ModaliasHandler。这些处理器分别负责特定类型的设备事件处理，如挂载设备节点、管理固件目录等。

4. 初始化 UeventListener

   int ueventd_main(int argc, char** argv) {...UeventListener uevent_listener(ueventd_configuration.uevent_socket_rcvbuf_size);...
   }
   

   • 创建一个 UeventListener 对象，用于监听内核通过 uevent socket 发送的 uevents，并配置接收缓冲区大小。

5. 冷启动处理

   int ueventd_main(int argc, char** argv) {...if (!android::base::GetBoolProperty(kColdBootDoneProp, false)) {ColdBoot cold_boot(uevent_listener, uevent_handlers,ueventd_configuration.enable_parallel_restorecon,ueventd_configuration.parallel_restorecon_dirs);cold_boot.Run();}...
   }
   

   • 检查系统是否完成冷启动（android::base::GetBoolProperty(kColdBootDoneProp, false)），如果尚未完成，则执行 ColdBoot 类的 Run() 方法进行冷启动相关的设备事件处理和权限恢复。

6. 冷启动完成通知

   int ueventd_main(int argc, char** argv) {...for (auto& uevent_handler : uevent_handlers) {uevent_handler->ColdbootDone();}...
   }
   

   • 所有 UeventHandler 对象调用 ColdbootDone() 方法以表明冷启动阶段已完成。

7. 信号处理

   int ueventd_main(int argc, char** argv) {...signal(SIGCHLD, SIG_IGN);while (waitpid(-1, nullptr, WNOHANG) > 0) {}...
   }
   

   • 忽略子进程结束信号 SIGCHLD，并清理任何已退出但未被收集的子进程。

8. 恢复优先级

   int ueventd_main(int argc, char** argv) {...setpriority(PRIO_PROCESS, 0, 0);...
   }
   

   • 调用 setpriority(PRIO_PROCESS, 0, 0) 来恢复进程的默认优先级。

9. 主循环

   int ueventd_main(int argc, char** argv) {...uevent_listener.Poll([&uevent_handlers](const Uevent& uevent) {for (auto& uevent_handler : uevent_handlers) {uevent_handler->HandleUevent(uevent);}return ListenerAction::kContinue;});...
   }
   

   • 进入主循环，使用 UeventListener 的 Poll() 方法监听 uevents。当接收到 uevent 时，遍历所有 UeventHandler 对象并调用它们的 HandleUevent() 方法来处理相应的事件。

---

总结：ueventd_main 函数在 Android 启动过程中扮演着核心角色，它负责监听和处理与硬件设备状态变化相关的事件，确保系统能够正确识别并响应设备添加、移除或属性更改等操作，从而使得设备驱动和用户空间能够有效地交互。

四、FirstStageMain

FirstStageMain 是 Android 系统启动流程中第一阶段初始化的主入口函数，它负责在系统启动早期进行一系列关键的系统设置和挂载操作。

源码路径：/system/core/init/first_stage_init.cpp

1. 信号处理

   int FirstStageMain(int argc, char** argv) {if (REBOOT_BOOTLOADER_ON_PANIC) {InstallRebootSignalHandlers();}...
   }
   

   • 如果定义了 REBOOT_BOOTLOADER_ON_PANIC，则安装重启到引导加载器的信号处理程序，在系统出现 panic 时执行。

2. 时间戳记录与错误检查宏

   int FirstStageMain(int argc, char** argv) {...boot_clock::time_point start_time = boot_clock::now();std::vector<std::pair<std::string, int>> errors;
   #define CHECKCALL(x) \if ((x) != 0) errors.emplace_back(#x " failed", errno);...
   }
   

   • 记录启动时间点。
   • 定义一个宏 CHECKCALL(x)，用于调用函数 x 并检查其返回值是否为0（表示成功），若非0，则将错误信息添加至错误列表中。

3. 设置文件或目录的默认权限

   int FirstStageMain(int argc, char** argv) {...umask(0);...
   }
   

   • 当 umask 值为 0 时，意味着新建的文件或目录将具有最大权限，即对于文件来说是 666（rw-rw-rw-），对于目录来说是 777（rwxrwxrwx）。

4. 环境清理与基本文件系统准备

   int FirstStageMain(int argc, char** argv) {...CHECKCALL(clearenv());CHECKCALL(setenv("PATH", _PATH_DEFPATH, 1));CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"));CHECKCALL(mkdir("/dev/pts", 0755));CHECKCALL(mkdir("/dev/socket", 0755));CHECKCALL(mkdir("/dev/dm-user", 0755));CHECKCALL(mount("devpts", "/dev/pts", "devpts", 0, NULL));
   #define MAKE_STR(x) __STRING(x)CHECKCALL(mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC)));
   #undef MAKE_STRCHECKCALL(chmod("/proc/cmdline", 0440));std::string cmdline;android::base::ReadFileToString("/proc/cmdline", &cmdline);chmod("/proc/bootconfig", 0440);std::string bootconfig;android::base::ReadFileToString("/proc/bootconfig", &bootconfig);gid_t groups[] = {AID_READPROC};CHECKCALL(setgroups(arraysize(groups), groups));CHECKCALL(mount("sysfs", "/sys", "sysfs", 0, NULL));CHECKCALL(mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL));...
   }
   

   • 清除当前进程的环境变量。
   • 设置 PATH 环境变量为默认值。
   • 挂载临时文件系统 tmpfs 到 /dev 目录下，并创建必要的子目录如 /dev/pts、/dev/socket 和 /dev/dm-user。
   • 按需挂载 proc、sysfs、selinuxfs 文件系统并调整相关权限。

5. 特殊设备节点创建

   int FirstStageMain(int argc, char** argv) {...CHECKCALL(mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11)));if constexpr (WORLD_WRITABLE_KMSG) {CHECKCALL(mknod("/dev/kmsg_debug", S_IFCHR | 0622, makedev(1, 11)));}CHECKCALL(mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8)));CHECKCALL(mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9)));CHECKCALL(mknod("/dev/ptmx", S_IFCHR | 0666, makedev(5, 2)));CHECKCALL(mknod("/dev/null", S_IFCHR | 0666, makedev(1, 3)));CHECKCALL(mount("tmpfs", "/mnt", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,"mode=0755,uid=0,gid=1000"));CHECKCALL(mkdir("/mnt/vendor", 0755));CHECKCALL(mkdir("/mnt/product", 0755));CHECKCALL(mount("tmpfs", "/debug_ramdisk", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,"mode=0755,uid=0,gid=0"));CHECKCALL(mount("tmpfs", kSecondStageRes, "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,"mode=0755,uid=0,gid=0"))
   #undef CHECKCALL...
   }
   

   • 创建 kmsg、random、urandom、ptmx 和 null 等特殊设备节点。

6. 日志初始化与权限控制

   int FirstStageMain(int argc, char** argv) {...SetStdioToDevNull(argv);InitKernelLogging(argv);...
   }
   

   • 将标准输入输出重定向至 /dev/null，以避免不必要的输出干扰。
   • 初始化内核日志功能。

7. 挂载特定临时文件系统

   int FirstStageMain(int argc, char** argv) {...LOG(INFO) << "init first stage started!";auto old_root_dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir("/"), closedir};if (!old_root_dir) {PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";}struct stat old_root_info;if (stat("/", &old_root_info) != 0) {PLOG(ERROR) << "Could not stat(\"/\"), not freeing ramdisk";old_root_dir.reset();}...
   }
   

   • 在 /mnt、/mnt/vendor 和 /mnt/product 下挂载临时文件系统，为后续挂载分区做准备。
   • 创建 /debug_ramdisk 和第二阶段资源存储目录，并挂载临时文件系统。

8. 模块加载及计时

   int FirstStageMain(int argc, char** argv) {...auto want_console = ALLOW_FIRST_STAGE_CONSOLE ? FirstStageConsole(cmdline, bootconfig) : 0;auto want_parallel =bootconfig.find("androidboot.load_modules_parallel = \"true\"") != std::string::npos;boot_clock::time_point module_start_time = boot_clock::now();int module_count = 0;if (!LoadKernelModules(IsRecoveryMode() && !ForceNormalBoot(cmdline, bootconfig), want_console,want_parallel, module_count)) {if (want_console != FirstStageConsoleParam::DISABLED) {LOG(ERROR) << "Failed to load kernel modules, starting console";} else {LOG(FATAL) << "Failed to load kernel modules";}}if (module_count > 0) {auto module_elapse_time = std::chrono::duration_cast<std::chrono::milliseconds>(boot_clock::now() - module_start_time);setenv(kEnvInitModuleDurationMs, std::to_string(module_elapse_time.count()).c_str(), 1);LOG(INFO) << "Loaded " << module_count << " kernel modules took "<< module_elapse_time.count() << " ms";}...
   }
   

   • 加载内核模块，可以按照配置选择是否并行加载，并统计加载耗时。

9. 创建设备节点与控制台启动

   int FirstStageMain(int argc, char** argv) {...bool created_devices = false;if (want_console == FirstStageConsoleParam::CONSOLE_ON_FAILURE) {if (!IsRecoveryMode()) {created_devices = DoCreateDevices();if (!created_devices) {LOG(ERROR) << "Failed to create device nodes early";}}StartConsole(cmdline);}...
   }
   

   • 根据需要创建设备节点。
   • 根据配置决定是否启动控制台。

10. ramdisk 属性复制

    int FirstStageMain(int argc, char** argv) {...if (access(kBootImageRamdiskProp, F_OK) == 0) {std::string dest = GetRamdiskPropForSecondStage();std::string dir = android::base::Dirname(dest);std::error_code ec;if (!fs::create_directories(dir, ec) && !!ec) {LOG(FATAL) << "Can't mkdir " << dir << ": " << ec.message();}if (!fs::copy_file(kBootImageRamdiskProp, dest, ec)) {LOG(FATAL) << "Can't copy " << kBootImageRamdiskProp << " to " << dest << ": "<< ec.message();}LOG(INFO) << "Copied ramdisk prop to " << dest;}...
    }
    

    • 将 bootimage 中 ramdisk 的属性复制到指定位置以便于第二阶段使用。

11. 调试模式支持

    int FirstStageMain(int argc, char** argv) {...if (access("/force_debuggable", F_OK) == 0) {constexpr const char adb_debug_prop_src[] = "/adb_debug.prop";constexpr const char userdebug_plat_sepolicy_cil_src[] = "/userdebug_plat_sepolicy.cil";std::error_code ec;if (access(adb_debug_prop_src, F_OK) == 0 &&!fs::copy_file(adb_debug_prop_src, kDebugRamdiskProp, ec)) {LOG(WARNING) << "Can't copy " << adb_debug_prop_src << " to " << kDebugRamdiskProp<< ": " << ec.message();}if (access(userdebug_plat_sepolicy_cil_src, F_OK) == 0 &&!fs::copy_file(userdebug_plat_sepolicy_cil_src, kDebugRamdiskSEPolicy, ec)) {LOG(WARNING) << "Can't copy " << userdebug_plat_sepolicy_cil_src << " to "<< kDebugRamdiskSEPolicy << ": " << ec.message();}setenv("INIT_FORCE_DEBUGGABLE", "true", 1);}...
    }
    

    • 当检测到 “/force_debuggable” 文件存在时，会启用用户debug模式相关的设置，例如允许adb root访问等。

12. 切换根文件系统

    int FirstStageMain(int argc, char** argv) {...if (ForceNormalBoot(cmdline, bootconfig)) {mkdir("/first_stage_ramdisk", 0755);PrepareSwitchRoot();if (mount("/first_stage_ramdisk", "/first_stage_ramdisk", nullptr, MS_BIND, nullptr) != 0) {PLOG(FATAL) << "Could not bind mount /first_stage_ramdisk to itself";}SwitchRoot("/first_stage_ramdisk");}...
    }
    

    • 如果满足条件（例如非恢复模式且不强制正常启动），则执行切换根文件系统的操作，包括创建新目录、绑定挂载以及调用 SwitchRoot() 函数。

13. 完成第一阶段挂载

    int FirstStageMain(int argc, char** argv) {...if (!DoFirstStageMount(!created_devices)) {LOG(FATAL) << "Failed to mount required partitions early ...";}...
    }
    

    • 执行 DoFirstStageMount() 函数来挂载启动过程中所需的必要分区。

14. 释放旧 ramdisk 资源

    int FirstStageMain(int argc, char** argv) {...struct stat new_root_info;if (stat("/", &new_root_info) != 0) {PLOG(ERROR) << "Could not stat(\"/\"), not freeing ramdisk";old_root_dir.reset();}if (old_root_dir && old_root_info.st_dev != new_root_info.st_dev) {FreeRamdisk(old_root_dir.get(), old_root_info.st_dev);}...
    }
    

    • 验证旧根文件系统是否已成功切换，如果已切换，则释放旧的 ramdisk 相关资源。

15. 其他系统设置

    int FirstStageMain(int argc, char** argv) {...SetInitAvbVersionInRecovery();setenv(kEnvFirstStageStartedAt, std::to_string(start_time.time_since_epoch().count()).c_str(),1);
    

    • 设置 AVB 版本信息等额外操作。

16. 进入 SetupSelinux

    int FirstStageMain(int argc, char** argv) {...const char* path = "/system/bin/init";const char* args[] = {path, "selinux_setup", nullptr};auto fd = open("/dev/kmsg", O_WRONLY | O_CLOEXEC);dup2(fd, STDOUT_FILENO);dup2(fd, STDERR_FILENO);close(fd);execv(path, const_cast<char**>(args));PLOG(FATAL) << "execv(\"" << path << "\") failed";return 1;
    }
    

    • 通过 execv() 函数执行 /system/bin/init 进程，传入 “selinux_setup” 参数作为子进程的启动参数，开始进入 SetupSelinux。

---

总结：整个 FirstStageMain 函数确保了 Android 系统在初始启动阶段能够正确地设置文件系统结构、加载必需的内核模块、建立基础设备节点以及安全地切换到下一阶段的初始化流程。

五、SetupSelinux

SetupSelinux 是 Android 系统启动流程中用于设置和初始化 SELinux 环境的关键函数。

源码路径：/system/core/init/selinux.cpp

1. 标准输入输出重定向与内核日志初始化

   int SetupSelinux(char** argv) {SetStdioToDevNull(argv);InitKernelLogging(argv);...
   }
   

   • SetStdioToDevNull(argv) 将标准输入、输出和错误重定向至 /dev/null，防止无用的日志输出。
   • InitKernelLogging(argv) 初始化内核日志功能。

2. 信号处理

   int SetupSelinux(char** argv) {...if (REBOOT_BOOTLOADER_ON_PANIC) {InstallRebootSignalHandlers();}...
   }
   

   • 如果定义了 REBOOT_BOOTLOADER_ON_PANIC，则安装重启到引导加载器的信号处理程序。

3. 计时并挂载分区

   int SetupSelinux(char** argv) {...boot_clock::time_point start_time = boot_clock::now();MountMissingSystemPartitions();...
   }
   

   • 记录开始时间点，并调用 MountMissingSystemPartitions() 挂载必要的系统分区。

4. SELinux 内核日志设置

   int SetupSelinux(char** argv) {...SelinuxSetupKernelLogging();...
   }
   

   • 调用 SelinuxSetupKernelLogging() 来设置SELinux相关的内核日志参数。

5. 准备和读取SELinux策略

   int SetupSelinux(char** argv) {...PrepareApexSepolicy();std::string policy;ReadPolicy(&policy);CleanupApexSepolicy();...
   }
   

   • 准备Apex SELinux策略文件 (PrepareApexSepolicy)。
   • 读取SELinux策略文件的内容并将它存储在字符串变量 policy 中。
   • 清理 Apex SELinux 策略文件相关资源。

6. 管理 snapuserd 守护进程

   int SetupSelinux(char** argv) {...auto snapuserd_helper = SnapuserdSelinuxHelper::CreateIfNeeded();if (snapuserd_helper) {snapuserd_helper->StartTransition();}...
   }
   

   • 创建或获取一个 SnapuserdSelinuxHelper 对象来管理 snapuserd 守护进程的 SELinux 上下文转换。
   • 如果需要，杀死旧的 snapuserd 进程以避免产生审计消息，并开始转换过程。

7. 加载 SELinux 策略

   int SetupSelinux(char** argv) {...LoadSelinuxPolicy(policy);...
   }
   

   • 使用之前读取的 policy 字符串内容加载 SELinux 策略 (LoadSelinuxPolicy(policy))。

8. 完成 snapuserd 的 SELinux 上下文转换

   int SetupSelinux(char** argv) {...if (snapuserd_helper) {snapuserd_helper->FinishTransition();snapuserd_helper = nullptr;}...
   }
   

   • 如果存在 snapuserd_helper，完成其 SELinux 上下文转换过程，并释放该对象。

9. 恢复上下文与设置强制执行模式

   int SetupSelinux(char** argv) {...if (selinux_android_restorecon("/dev/selinux/", SELINUX_ANDROID_RESTORECON_RECURSE) == -1) {PLOG(FATAL) << "restorecon failed of /dev/selinux failed";}SelinuxSetEnforcement();...
   }
   

   • 恢复 /dev/selinux/ 目录及其子目录下的文件到正确的SELinux上下文。
   • 设置 SELinux 进入强制执行模式 (SelinuxSetEnforcement)。

10. 针对 init 进程进行额外的上下文恢复

    int SetupSelinux(char** argv) {...if (selinux_android_restorecon("/system/bin/init", 0) == -1) {PLOG(FATAL) << "restorecon failed of /system/bin/init failed";}...
    }
    

    • 特别对 /system/bin/init 进行 SELinux 上下文恢复，确保其拥有正确权限以便进行后续启动操作。

11. 设置环境变量

    int SetupSelinux(char** argv) {...setenv(kEnvSelinuxStartedAt, std::to_string(start_time.time_since_epoch().count()).c_str(), 1);...
    }
    

    • 设置环境变量 kEnvSelinuxStartedAt 记录 SELinux 启动的时间点。

12. 执行第二阶段 init 进程

    int SetupSelinux(char** argv) {...const char* path = "/system/bin/init";const char* args[] = {path, "second_stage", nullptr};execv(path, const_cast<char**>(args));PLOG(FATAL) << "execv(\"" << path << "\") failed";return 1;
    }
    

    • 准备参数数组，包含命令路径 “/system/bin/init” 和参数 “second_stage”。
    • 使用 execv 系统调用执行新的 init 进程，进入系统的第二阶段初始化。
    • 如果 execv 函数返回（通常表示出错），会记录致命错误并退出程序。由于在成功执行 execv 后不会返回，所以这里的 PLOG(FATAL) … 是一种异常情况处理。

---

总结：通过 SetupSelinux 函数的执行，Android 系统能够在启动时正确地建立和启用 SELinux 安全机制，为后续系统的运行提供安全保障。

六、SecondStageMain

SecondStageMain 函数是 Android 系统启动过程中的第二个阶段，主要负责更深层次的系统初始化工作。

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

1. 信号处理

   int SecondStageMain(int argc, char** argv) {if (REBOOT_BOOTLOADER_ON_PANIC) {InstallRebootSignalHandlers();}boot_clock::time_point start_time = boot_clock::now();trigger_shutdown = [](const std::string& command) { shutdown_state.TriggerShutdown(command); };SetStdioToDevNull(argv);InitKernelLogging(argv);LOG(INFO) << "init second stage started!";SelinuxSetupKernelLogging();...
   }
   

   • 设置重启至引导加载器的信号处理程序，并忽略 SIGPIPE 信号，防止因管道破裂导致的进程崩溃。

2. 资源准备与清理

   int SecondStageMain(int argc, char** argv) {...if (setenv("PATH", _PATH_DEFPATH, 1) != 0) {PLOG(FATAL) << "Could not set $PATH to '" << _PATH_DEFPATH << "' in second stage";}{struct sigaction action = {.sa_flags = SA_RESTART};action.sa_handler = [](int) {};sigaction(SIGPIPE, &action, nullptr);}if (auto result =WriteFile("/proc/1/oom_score_adj", StringPrintf("%d", DEFAULT_OOM_SCORE_ADJUST));!result.ok()) {LOG(ERROR) << "Unable to write " << DEFAULT_OOM_SCORE_ADJUST<< " to /proc/1/oom_score_adj: " << result.error();}keyctl_get_keyring_ID(KEY_SPEC_SESSION_KEYRING, 1);close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));const char* force_debuggable_env = getenv("INIT_FORCE_DEBUGGABLE");bool load_debug_prop = false;if (force_debuggable_env && AvbHandle::IsDeviceUnlocked()) {load_debug_prop = "true"s == force_debuggable_env;}unsetenv("INIT_FORCE_DEBUGGABLE");if (!load_debug_prop) {UmountDebugRamdisk();}...
   }
   

   • 设置 PATH 变量值。
   • 调整 init 进程及其子进程的内存管理器 OOM 分数调整值。
   • 设置会话密钥环，保证进程间共享加密密钥的安全性。
   • 标记正在启动状态，打开 /dev/.booting 文件。
   • 根据解锁状态和环境变量决定是否加载调试属性，并卸载调试 ramdisk。

3. 系统服务和属性初始化

   int SecondStageMain(int argc, char** argv) {...PropertyInit();UmountSecondStageRes();if (load_debug_prop) {UmountDebugRamdisk();}MountExtraFilesystems();SelabelInitialize();SelinuxRestoreContext();...
   }
   

   • 初始化属性服务，加载系统属性。
   • 卸载第二阶段资源。
   • 挂载额外的文件系统。
   • 初始化 SELinux 并恢复上下文。

4. 事件循环与回调设置

   int SecondStageMain(int argc, char** argv) {...Epoll epoll;if (auto result = epoll.Open(); !result.ok()) {PLOG(FATAL) << result.error();}epoll.SetFirstCallback(ReapAnyOutstandingChildren);InstallSignalFdHandler(&epoll);InstallInitNotifier(&epoll);StartPropertyService(&property_fd);...
   }
   

   • 使用 Epoll 实现 I/O 多路复用，设置信号处理回调，处理子进程退出事件。
   • 安装 Init 通知器，启动属性服务。

5. 关键数据记录与设置

   int SecondStageMain(int argc, char** argv) {...RecordStageBoottimes(start_time);if (const char* avb_version = getenv("INIT_AVB_VERSION"); avb_version != nullptr) {SetProperty("ro.boot.avb_version", avb_version);}unsetenv("INIT_AVB_VERSION");...
   }
   

   • 记录启动阶段的时间点供 bootstat 使用。
   • 设置 libavb 版本属性。

6. 系统特定功能

   int SecondStageMain(int argc, char** argv) {...fs_mgr_vendor_overlay_mount_all();export_oem_lock_status();MountHandler mount_handler(&epoll);SetUsbController();SetKernelVersion();const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();Action::set_function_map(&function_map);if (!SetupMountNamespaces()) {PLOG(FATAL) << "SetupMountNamespaces failed";}InitializeSubcontext();ActionManager& am = ActionManager::GetInstance();ServiceList& sm = ServiceList::GetInstance();LoadBootScripts(am, sm);...
   }
   

   • 负责厂商层叠挂载、导出 OEM 锁定状态、挂载处理器、设置 USB 控制器、设置内核版本等。
   • 设置内置函数映射表，加载启动脚本。

7. 初始化命名空间与控制组

   int SecondStageMain(int argc, char** argv) {...if (false) DumpState();auto is_running = android::gsi::IsGsiRunning() ? "1" : "0";SetProperty(gsi::kGsiBootedProp, is_running);auto is_installed = android::gsi::IsGsiInstalled() ? "1" : "0";SetProperty(gsi::kGsiInstalledProp, is_installed);...
   }
   

   • 设置挂载命名空间。
   • 初始化子上下文。

8. 调度内置动作

   int SecondStageMain(int argc, char** argv) {...am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");am.QueueBuiltinAction(TestPerfEventSelinuxAction, "TestPerfEventSelinux");am.QueueBuiltinAction(ConnectEarlyStageSnapuserdAction, "ConnectEarlyStageSnapuserd");am.QueueEventTrigger("early-init");am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");am.QueueBuiltinAction(SetMmapRndBitsAction, "SetMmapRndBits");Keychords keychords;am.QueueBuiltinAction([&epoll, &keychords](const BuiltinArguments& args) -> Result<void> {for (const auto& svc : ServiceList::GetInstance()) {keychords.Register(svc->keycodes());}keychords.Start(&epoll, HandleKeychord);return {};},"KeychordInit");am.QueueEventTrigger("init");...
   }
   

   • 队列化一系列内置动作，如设置 cgroups、设置 kptr_restrict 等安全选项。
   • 注册并启动按键组合（Keychord）处理。

9. 启动与触发事件

   int SecondStageMain(int argc, char** argv) {...std::string bootmode = GetProperty("ro.bootmode", "");if (bootmode == "charger") {am.QueueEventTrigger("charger");} else {am.QueueEventTrigger("late-init");}am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");...
   }
   

   • 根据不同的启动模式触发相应事件（正常启动、充电模式等）。
   • 基于当前属性状态触发属性关联的事件。

10. 主循环

    int SecondStageMain(int argc, char** argv) {...while (true) {const boot_clock::time_point far_future = boot_clock::time_point::max();boot_clock::time_point next_action_time = far_future;auto shutdown_command = shutdown_state.CheckShutdown();if (shutdown_command) {LOG(INFO) << "Got shutdown_command '" << *shutdown_command<< "' Calling HandlePowerctlMessage()";HandlePowerctlMessage(*shutdown_command);}if (!(prop_waiter_state.MightBeWaiting() || Service::is_exec_service_running())) {am.ExecuteOneCommand();if (am.HasMoreCommands()) {next_action_time = boot_clock::now();}}if (!IsShuttingDown()) {auto next_process_action_time = HandleProcessActions();if (next_process_action_time) {next_action_time = std::min(next_action_time, *next_process_action_time);}}std::optional<std::chrono::milliseconds> epoll_timeout;if (next_action_time != far_future) {epoll_timeout = std::chrono::ceil<std::chrono::milliseconds>(std::max(next_action_time - boot_clock::now(), 0ns));}auto epoll_result = epoll.Wait(epoll_timeout);if (!epoll_result.ok()) {LOG(ERROR) << epoll_result.error();}if (!IsShuttingDown()) {HandleControlMessages();SetUsbController();}}...
    }
    

    • 在无限循环中，根据队列中的动作计划执行相关命令。
    • 监听并处理控制消息，如电源管理命令（如关机、重启等）。
    • 处理进程管理和重启操作。
    • 检查并更新 USB 控制器状态。

---

总结：SecondStageMain 函数对 Android 系统进行全面深入的初始化，包括设置系统资源、挂载文件系统、启动关键服务、初始化安全性组件以及执行启动脚本等。整个函数通过事件循环持续监控并响应系统内部及外部事件，直至系统完全启动就绪。

七、信号处理

init 是一个守护进程，为了防止 init 的子进程成为僵尸进程(zombie process)，需要 init 在子进程在结束时获取子进程的结束码，通过结束码将程序表中的子进程移除，防止成为僵尸进程的子进程占用程序表的空间（程序表的空间达到上限时，系统就不能再启动新的进程了，会引起严重的系统问题）。

子进程重启流程如下图所示：

信号处理主要工作：

• 初始化信号 signal 句柄
• 循环处理子进程
• 注册 epoll 句柄
• 处理子进程终止

注意：EPOLL 类似于 POLL，是 Linux 中用来做事件触发的，跟 EventBus 功能差不多。Linux 很长的时间都在使用 select 来做事件触发，它是通过轮询来处理的，轮询的 fd 数目越多，自然耗时越多，对于大量的描述符处理，EPOLL 更有优势。

1. InstallSignalFdHandler

   InstallSignalFdHandler 用于在 Linux 系统中设置信号处理。

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

   static void InstallSignalFdHandler(Epoll* epoll) {// 设置一个默认的 SIGCHLD 信号处理器，并使用 sigaction 函数应用了 SA_NOCLDSTOP 标志。这可以防止当子进程停止或继续时，signalfd 接收到 SIGCHLD 信号。const struct sigaction act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDSTOP };sigaction(SIGCHLD, &act, nullptr);// 创建一个信号集，将 SIGCHLD 信号添加到该集中。sigset_t mask;sigemptyset(&mask);sigaddset(&mask, SIGCHLD);// 如果当前进程没有重启能力（可能是在容器中运行），那么它还会将 SIGTERM 信号添加到信号集中。这是因为在容器环境中，接收到 SIGTERM 信号通常会导致系统关闭。if (!IsRebootCapable()) {sigaddset(&mask, SIGTERM);}// 使用 sigprocmask 函数阻塞这些信号。如果阻塞失败，它将记录一条致命错误日志。if (sigprocmask(SIG_BLOCK, &mask, nullptr) == -1) {PLOG(FATAL) << "failed to block signals";}// 使用 pthread_atfork 函数注册一个 fork 处理器，该处理器在子进程中解除信号阻塞。如果注册失败，它将记录一条致命错误日志。const int result = pthread_atfork(nullptr, nullptr, &UnblockSignals);if (result != 0) {LOG(FATAL) << "Failed to register a fork handler: " << strerror(result);}// 使用 signalfd 函数创建一个信号文件描述符，用于接收信号。如果创建失败，它将记录一条致命错误日志。signal_fd = signalfd(-1, &mask, SFD_CLOEXEC);if (signal_fd == -1) {PLOG(FATAL) << "failed to create signalfd";}// 使用 epoll->RegisterHandler 函数注册一个处理器，用于处理从信号文件描述符接收到的信号。如果注册失败，它将记录一条致命错误日志。constexpr int flags = EPOLLIN | EPOLLPRI;if (auto result = epoll->RegisterHandler(signal_fd, HandleSignalFd, flags); !result.ok()) {LOG(FATAL) << result.error();}
   }
   

   InstallSignalFdHandler 函数的主要目的是设置一个系统，使得当特定的信号发生时，可以通过文件描述符来接收和处理这些信号。

2. RegisterHandler

   RegisterHandler 在 Epoll 类中定义。这个函数的目的是注册一个处理器（Handler）来处理特定文件描述符（fd）的事件。这是通过 Linux 的 epoll 机制实现的，epoll 是一种 I/O 多路复用技术。

   源码路径：/system/core/init/epoll.cpp

   Result<void> Epoll::RegisterHandler(int fd, Handler handler, uint32_t events) {// 检查是否指定了事件（events）。如果没有指定任何事件，函数将返回一个错误。if (!events) {return Error() << "Must specify events";}// 尝试将文件描述符（fd）和一个包含事件和处理器的 Info 对象插入到 epoll_handlers_ 映射中。auto [it, inserted] = epoll_handlers_.emplace(fd, Info{.events = events,.handler = std::move(handler),});// 如果插入失败（也就是说，给定的文件描述符已经有一个处理器），函数将返回一个错误。if (!inserted) {return Error() << "Cannot specify two epoll handlers for a given FD";}// 创建一个 epoll_event 结构体，该结构体包含了事件和文件描述符。epoll_event ev = {.events = events,.data.fd = fd,};// 使用 epoll_ctl 函数将文件描述符添加到 epoll 实例中。如果这个操作失败，它将从 epoll_handlers_ 映射中删除文件描述符，并返回一个错误。if (epoll_ctl(epoll_fd_.get(), EPOLL_CTL_ADD, fd, &ev) == -1) {Result<void> result = ErrnoError() << "epoll_ctl failed to add fd";epoll_handlers_.erase(fd);return result;}// 如果所有操作都成功，函数将返回一个空的 Result 对象，表示操作成功。return {};
   }
   

   RegisterHandler 函数的主要用途是设置 epoll，使得当文件描述符上发生指定的事件时，可以调用相应的处理器来处理这些事件。

3. HandleSignalFd

   HandleSignalFd 用于处理通过 signal_fd 接收到的信号。这个函数使用了 Linux 的 signalfd 机制，该机制允许通过文件描述符接收信号。

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

   static void HandleSignalFd() {// 定义了一个 signalfd_siginfo 结构体，用于存储从 signal_fd 读取的信号信息。signalfd_siginfo siginfo;// 尝试从 signal_fd 读取信号信息。如果读取失败，将记录一条错误日志并返回。ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo)));// 如果成功读取到信号信息，将检查读取的字节数是否等于 signalfd_siginfo 的大小。如果不等，将记录一条错误日志并返回。if (bytes_read != sizeof(siginfo)) {PLOG(ERROR) << "Failed to read siginfo from signal_fd";return;}switch (siginfo.ssi_signo) {case SIGCHLD:ReapAnyOutstandingChildren();break;case SIGTERM:HandleSigtermSignal(siginfo);break;default:LOG(ERROR) << "signal_fd: received unexpected signal " << siginfo.ssi_signo;break;}
   }
   

   HandleSignalFd 函数的主要用途是处理通过 signal_fd 接收到的信号，以便在接收到特定的信号时执行相应的操作。

4. ReapOneProcess

   ReapOneProcess 用于处理子进程的结束。它使用了 Linux 的 waitid 和 waitpid 系统调用来收集子进程的退出状态，防止子进程变成僵尸进程。

   源码路径：/system/core/init/sigchld_handler.cpp

   void ReapAnyOutstandingChildren() {while (ReapOneProcess() != 0) {}
   }static pid_t ReapOneProcess() {// 定义一个 siginfo_t 结构体，用于存储从 waitid 系统调用中获取的信息。siginfo_t siginfo = {};// 调用 waitid 系统调用来获取一个僵尸进程的 PID，或者得知没有更多的僵尸进程需要处理。注意，这个调用并不实际收集僵尸进程的退出状态，这个操作在后面进行。if (TEMP_FAILURE_RETRY(waitid(P_ALL, 0, &siginfo, WEXITED | WNOHANG | WNOWAIT)) != 0) {PLOG(ERROR) << "waitid failed";return 0;}// 如果 waitid 调用失败，它将记录一条错误日志并返回 0。const pid_t pid = siginfo.si_pid;if (pid == 0) {DCHECK_EQ(siginfo.si_signo, 0);return 0;}// 如果 waitid 调用成功，它将检查返回的 PID 是否为 0。如果是，它将确保信号编号为 0，然后返回0。如果 PID 不为 0，它将确保信号编号为SIGCHLD。DCHECK_EQ(siginfo.si_signo, SIGCHLD);// 创建一个作用域保护器（scope guard）。这个保护器在函数返回时会自动调用 waitpid 系统调用来收集僵尸进程的退出状态。auto reaper = make_scope_guard([pid] { TEMP_FAILURE_RETRY(waitpid(pid, nullptr, WNOHANG)); });std::string name;std::string wait_string;Service* service = nullptr;// 尝试找到与 PID 对应的服务。如果找到，将记录服务的名称和 PID，以及服务的执行时间。如果没有找到，将记录 PID。if (SubcontextChildReap(pid)) {name = "Subcontext";} else {service = ServiceList::GetInstance().FindService(pid, &Service::pid);if (service) {name = StringPrintf("Service '%s' (pid %d)", service->name().c_str(), pid);if (service->flags() & SVC_EXEC) {auto exec_duration = boot_clock::now() - service->time_started();auto exec_duration_ms =std::chrono::duration_cast<std::chrono::milliseconds>(exec_duration).count();wait_string = StringPrintf(" waiting took %f seconds", exec_duration_ms / 1000.0f);} else if (service->flags() & SVC_ONESHOT) {auto exec_duration = boot_clock::now() - service->time_started();auto exec_duration_ms =std::chrono::duration_cast<std::chrono::milliseconds>(exec_duration).count();wait_string = StringPrintf(" oneshot service took %f seconds in background",exec_duration_ms / 1000.0f);}} else {name = StringPrintf("Untracked pid %d", pid);}}// 检查子进程是正常退出还是因为接收到信号而退出，并记录相应的日志。if (siginfo.si_code == CLD_EXITED) {LOG(INFO) << name << " exited with status " << siginfo.si_status << wait_string;} else {LOG(INFO) << name << " received signal " << siginfo.si_status << wait_string;}// 如果没有找到与 PID 对应的服务，将记录一条日志，并返回 PID。if (!service) {LOG(INFO) << name << " did not have an associated service entry and will not be reaped";return pid;}// 如果找到了服务，将调用服务的 Reap 方法来处理服务的结束。service->Reap(siginfo);// 如果服务是临时的，将从服务列表中移除服务。if (service->flags() & SVC_TEMPORARY) {ServiceList::GetInstance().RemoveService(*service);}// 返回 PIDreturn pid;
   }
   

   ReapOneProcess 函数的主要用途是处理子进程的结束，收集子进程的退出状态，防止子进程变成僵尸进程，并处理与子进程相关的服务。

八、属性服务

我们在开发和调试过程中看到通过 property_set 可以轻松设置系统属性，那干嘛这里还要启动一个属性服务呢？这里其实涉及到一些权限的问题，不是所有进程都可以随意修改任何的系统属性，Android 将属性的设置统一交由 init 进程管理，其他进程不能直接修改属性，而只能通知 init 进程来修改，而在这过程中，init 进程可以进行权限控制，我们来看看具体的流程是什么：

1. PropertyInit

   PropertyInit 用于初始化 Android 系统的属性服务。这个服务用于管理系统的属性，这些属性是一些键值对，可以被系统的各个部分用来配置和通信。

   源码路径：/system/core/init/property_service.cpp

   void PropertyInit() {// 设置一个 SELinux 回调函数 PropertyAuditCallback，用于处理 SELinux 的审计事件。selinux_callback cb;cb.func_audit = PropertyAuditCallback;selinux_set_callback(SELINUX_CB_AUDIT, cb);// 创建一个名为 /dev/__properties__ 的目录，这个目录用于存储系统属性的信息。mkdir("/dev/__properties__", S_IRWXU | S_IXGRP | S_IXOTH);// 调用 CreateSerializedPropertyInfo 函数来创建序列化的属性信息。CreateSerializedPropertyInfo();// 调用 __system_property_area_init 函数来初始化属性区域。如果初始化失败，它将记录一条致命错误日志并退出。if (__system_property_area_init()) {LOG(FATAL) << "Failed to initialize property area";}// 尝试从默认路径加载序列化的属性信息文件。如果加载失败，它将记录一条致命错误日志并退出。if (!property_info_area.LoadDefaultPath()) {LOG(FATAL) << "Failed to load serialized property info file";}// 处理内核设备树（DT）和内核命令行中的参数。如果这两种方式都提供了参数，设备树中的属性将优先于命令行中的属性。ProcessKernelDt();ProcessKernelCmdline();// 处理启动配置。ProcessBootconfig();// 将内核变量传播到 init 使用的内部变量以及当前需要的属性。ExportKernelBootProps();// 加载启动默认属性。PropertyLoadBootDefaults();
   }
   

   PropertyInit 函数的主要用途是初始化系统属性服务，以便系统的各个部分可以使用系统属性进行配置和通信。

2. StartPropertyService

   StartPropertyService 函数用于启动属性服务。

   源码路径：/system/core/init/property_service.cpp

   void StartPropertyService(int* epoll_socket) {// 调用 InitPropertySet 函数来初始化一个名为 ro.property_service.version 的系统属性，其值为"2"。InitPropertySet("ro.property_service.version", "2");// 创建一个 UNIX 域套接字对，用于 property_service 和 init 之间的通信。如果套接字对的创建失败，它将记录一条致命错误日志并退出。int sockets[2];if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, sockets) != 0) {PLOG(FATAL) << "Failed to socketpair() between property_service and init";}// 将套接字对的一个端点赋值给 epoll_socket 和 from_init_socket，另一个端点赋值给 init_socket。*epoll_socket = from_init_socket = sockets[0];init_socket = sockets[1];// 调用 StartSendingMessages 函数来开始发送消息。StartSendingMessages();// 创建一个名为 PROP_SERVICE_NAME 的套接字，用于处理属性设置请求。如果套接字的创建失败，它将记录一条致命错误日志并退出。if (auto result = CreateSocket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,false, false, 0666, 0,0, {});result.ok()) {property_set_fd = *result;} else {LOG(FATAL) << "start_property_service socket creation failed: " << result.error();}// 调用 listen 函数来开始监听属性设置请求。listen(property_set_fd, 8);// 创建一个新的线程来运行 PropertyServiceThread 函数。这个函数用于处理属性设置请求。auto new_thread = std::thread{PropertyServiceThread};property_service_thread.swap(new_thread);// 检查 ro.property_service.async_persist_writes 系统属性的值。auto async_persist_writes =android::base::GetBoolProperty("ro.property_service.async_persist_writes", false);// 如果 async_persist_writes 为 true，将创建一个 PersistWriteThread 对象来异步写入持久化的属性。if (async_persist_writes) {persist_write_thread = std::make_unique<PersistWriteThread>();}
   }
   

   StartPropertyService 函数的主要用途是启动属性服务，以便系统的各个部分可以使用系统属性进行配置和通信。

3. handle_property_set_fd

   handle_property_set_fd 函数用于处理来自客户端的属性设置请求。这个函数通过接收和处理来自 UNIX 域套接字的消息来完成这个任务。

   源码路径：/system/core/init/property_service.cpp

   static void handle_property_set_fd() {static constexpr uint32_t kDefaultSocketTimeout = 2000;// 调用 accept4 函数来接收新的连接请求。如果接收失败，函数会直接返回。int s = accept4(property_set_fd, nullptr, nullptr, SOCK_CLOEXEC);if (s == -1) {return;}// 获取连接的对端的凭据（包括用户ID，组ID和进程ID）。ucred cr;socklen_t cr_size = sizeof(cr);if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) {close(s);PLOG(ERROR) << "sys_prop: unable to get SO_PEERCRED";return;}// 创建一个 SocketConnection 对象，用于处理和这个连接相关的操作。SocketConnection socket(s, cr);uint32_t timeout_ms = kDefaultSocketTimeout;// 从套接字中读取一个 32 位的命令。如果读取失败，函数会发送一个错误码并返回。uint32_t cmd = 0;if (!socket.RecvUint32(&cmd, &timeout_ms)) {PLOG(ERROR) << "sys_prop: error while reading command from the socket";socket.SendUint32(PROP_ERROR_READ_CMD);return;}switch (cmd) {// 如果命令是 PROP_MSG_SETPROP，函数会从套接字中读取属性的名字和值，然后调用 HandlePropertySetNoSocket 函数来设置属性。case PROP_MSG_SETPROP: {char prop_name[PROP_NAME_MAX];char prop_value[PROP_VALUE_MAX];if (!socket.RecvChars(prop_name, PROP_NAME_MAX, &timeout_ms) ||!socket.RecvChars(prop_value, PROP_VALUE_MAX, &timeout_ms)) {PLOG(ERROR) << "sys_prop(PROP_MSG_SETPROP): error while reading name/value from the socket";return;}prop_name[PROP_NAME_MAX-1] = 0;prop_value[PROP_VALUE_MAX-1] = 0;std::string source_context;if (!socket.GetSourceContext(&source_context)) {PLOG(ERROR) << "Unable to set property '" << prop_name << "': getpeercon() failed";return;}const auto& cr = socket.cred();std::string error;auto result = HandlePropertySetNoSocket(prop_name, prop_value, source_context, cr, &error);if (result != PROP_SUCCESS) {LOG(ERROR) << "Unable to set property '" << prop_name << "' from uid:" << cr.uid<< " gid:" << cr.gid << " pid:" << cr.pid << ": " << error;}break;}// 如果命令是 PROP_MSG_SETPROP2，函数会从套接字中读取属性的名字和值，然后调用 HandlePropertySet 函数来设置属性。这个函数会处理异步属性设置的情况。case PROP_MSG_SETPROP2: {std::string name;std::string value;if (!socket.RecvString(&name, &timeout_ms) ||!socket.RecvString(&value, &timeout_ms)) {PLOG(ERROR) << "sys_prop(PROP_MSG_SETPROP2): error while reading name/value from the socket";socket.SendUint32(PROP_ERROR_READ_DATA);return;}std::string source_context;if (!socket.GetSourceContext(&source_context)) {PLOG(ERROR) << "Unable to set property '" << name << "': getpeercon() failed";socket.SendUint32(PROP_ERROR_PERMISSION_DENIED);return;}const auto& cr = socket.cred();std::string error;auto result = HandlePropertySet(name, value, source_context, cr, &socket, &error);if (!result) {return;}if (*result != PROP_SUCCESS) {LOG(ERROR) << "Unable to set property '" << name << "' from uid:" << cr.uid<< " gid:" << cr.gid << " pid:" << cr.pid << ": " << error;}socket.SendUint32(*result);break;}// 如果命令是其他值，函数会记录一个错误日志并发送一个错误码。default:LOG(ERROR) << "sys_prop: invalid command " << cmd;socket.SendUint32(PROP_ERROR_INVALID_CMD);break;}
   }
   

   handle_property_set_fd 函数的主要用途是处理属性设置请求，以便系统的各个部分可以使用系统属性进行配置和通信。

九、init.rc

当属性服务建立完成后，init 的自身功能基本就告一段落，接下来需要来启动其他的进程。但是 init 进程如何启动其他进程呢？其他进程都是一个二进制文件，我们可以直接通过 exec 的命令方式来启动，例如 ./system/bin/init second_stage，来启动 init 进程的第二阶段。但是 Android 系统有那么多的 Native 进程，如果都通过传 exec 在代码中一个个的来执行进程，那无疑是一个灾难性的设计。在这个基础上 Android 推出了一个 init.rc 的机制，即类似通过读取配置文件的方式，来启动不同的进程。接下来我们就来看看 init.rc 是如何工作的。

init.rc 是一个配置文件，内部由 Android 初始化语言编写（Android Init Language）编写的脚本。init.rc 在 Android 设备的目录：./init.rc。init.rc 主要包含五种类型语句：Action、Command、Service、Option、Import。

1. Action

   Action 表示了一组命令（commands）组成.动作包括一个触发器，决定了何时运行这个 Action。Action 通过触发器（trigger），即以 on 开头的语句来决定执行相应的 service 的时机，具体有如下时机：

   • on early-init：在初始化早期阶段触发
   • on init：在初始化阶段触发
   • on late-init：在初始化晚期阶段触发
   • on boot/charger：当系统启动/充电时触发
   • on property:<key>=<value>：当属性值满足条件时触发

2. Command

   Command 是 Action 的命令列表中的命令，或者是 Service 中的选项 onrestart 的参数命令，命令将在所属事件发生时被一个个地执行。

   下面列举常用的命令：

   • class_start <service_class_name>：启动属于同一个 class 的所有服务
   • class_stop <service_class_name>：停止指定类的服务
   • start <service_name>：启动指定的服务，若已启动则跳过
   • stop <service_name>：停止正在运行的服务
   • setprop <name> <value>：设置属性值
   • mkdir <path>：创建指定目录
   • symlink <target> <sym_link>：创建连接到 <target> 的 <sym_link> 符号链接
   • write <path> <string>：向文件 path 中写入字符串
   • exec：fork 并执行，会阻塞 init 进程直到程序完毕
   • exprot <name> <name>：设定环境变量
   • loglevel <level>：设置 log 级别
   • hostname <name>：设置主机名
   • import <filename>：导入一个额外的 init 配置文件

3. Service

   服务 Service，以 service 开头，由 init 进程启动，一般运行在 init 的一个子进程，所以启动 service 前需要判断对应的可执行文件是否存在。

   命令：service <name><pathname> [ <argument> ]* <option> <option>

   参数	含义
   <name>	表示此服务的名称
   <pathname>	此服务所在路径，因为是可执行文件，所以一定有存储路径。
   <argument>	启动服务所带的参数
   <option>	对此服务的约束选项

   init 生成的子进程，定义在 rc 文件，其中每一个 service 在启动时会通过 fork 方式生成子进程。

   例如：service servicemanager /system/bin/servicemanager 代表的是服务名为 servicemanager，服务执行的路径为 /system/bin/servicemanager。

4. Options

   Options 是 Service 的可选项，与 service 配合使用：

   • disabled：不随 class 自动启动，只有根据 service 名才启动。
   • oneshot：service 退出后不再重启。
   • user/group：设置执行服务的用户/用户组，默认都是 root。
   • class：设置所属的类名，当所属类启动/退出时，服务也启动/停止，默认为 default。
   • onrestart：当服务重启时执行相应命令。
   • socket：创建名为 /dev/socket/<name> 的 socket。
   • critical：在规定时间内该 service 不断重启，则系统会重启并进入恢复模式。

   default：意味着 disabled=false，oneshot=false，critical=false。

5. Import

   用来导入其他的 rc 文件。

   命令：import <filename>

6. init.rc 解析过程 - LoadBootScripts

   LoadBootScripts 的主要任务是加载启动脚本。

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

   static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {// 创建一个Parser对象，该对象用于解析启动脚本。Parser parser = CreateParser(action_manager, service_list);// 尝试获取名为"ro.boot.init_rc"的属性，该属性的值应该是一个启动脚本的路径。std::string bootscript = GetProperty("ro.boot.init_rc", "");// 如果该属性不存在或者为空，那么它会尝试解析一系列默认的启动脚本。if (bootscript.empty()) {parser.ParseConfig("/system/etc/init/hw/init.rc");if (!parser.ParseConfig("/system/etc/init")) {// 如果在尝试解析时失败，那么它会将该路径添加到 late_import_paths 列表中，这意味着这些路径将在稍后再次尝试解析。late_import_paths.emplace_back("/system/etc/init");}parser.ParseConfig("/system_ext/etc/init");if (!parser.ParseConfig("/vendor/etc/init")) {// 如果在尝试解析时失败，那么它会将该路径添加到 late_import_paths 列表中，这意味着这些路径将在稍后再次尝试解析。late_import_paths.emplace_back("/vendor/etc/init");}if (!parser.ParseConfig("/odm/etc/init")) {// 如果在尝试解析时失败，那么它会将该路径添加到 late_import_paths 列表中，这意味着这些路径将在稍后再次尝试解析。late_import_paths.emplace_back("/odm/etc/init");}if (!parser.ParseConfig("/product/etc/init")) {// 如果在尝试解析时失败，那么它会将该路径添加到 late_import_paths 列表中，这意味着这些路径将在稍后再次尝试解析。late_import_paths.emplace_back("/product/etc/init");}} else {// 如果"ro.boot.init_rc"属性存在并且不为空，那么它会尝试解析该属性指定的启动脚本。parser.ParseConfig(bootscript);}
   }
   

   总的来说，LoadBootScripts 函数的目的是尽可能地加载和解析所有可用的启动脚本。

7. init.rc 解析过程 - CreateParser

   CreateParser 的主要任务是创建并配置一个Parser对象。它接受两个参数，一个是ActionManager类型的action_manager，另一个是ServiceList类型的service_list。

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

   Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {// 创建一个 Parser 对象。Parser parser;// 解析启动脚本中的"service"部分。parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, GetSubcontext(), std::nullopt));// 解析启动脚本中的"on"部分。parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, GetSubcontext()));// 解析启动脚本中的"import"部分。parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));// 返回配置好的 Parser 对象。return parser;
   }
   

   总的来说，这个函数的目的是创建一个能够解析启动脚本中的"service"、"on"和"import"部分的Parser对象。

8. init.rc 解析过程 - 执行 Action 动作

   按顺序把相关 Action 加入触发器队列，按顺序为 early-init -> init -> late-init。然后在循环中，执行所有触发器队列中 Action 带 Command 的执行函数。

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

   am.QueueEventTrigger("early-init");
   am.QueueEventTrigger("init");
   am.QueueEventTrigger("late-init");...while (true) {...if (!(prop_waiter_state.MightBeWaiting() || Service::is_exec_service_running())) {am.ExecuteOneCommand();...}...
   }...
   

9. init.rc 解析过程 - Zygote 启动

   Android 支持 64 位的编译，因此 zygote 本身也支持 32 位和 64 位。通过属性 ro.zygote 来控制不同版本的 zygote 进程启动。在 init.rc 的 import 段我们看到如下代码：

   import /system/etc/init/hw/init.${ro.zygote}.rc
   

   init.rc 位于 /system/core/rootdir/ 下。在这个路径下还包括三个关于 zygote 的 rc 文件。分别是 init.zygote32.rc、init.zygote64.rc、init.zygote64_32.rc，由硬件决定调用哪个文件。

   这里拿 64 位处理器为例，init.zygote64.rc 的代码如下所示：

   // 定义了一个名为"zygote"的服务，它使用/system/bin/app_process64程序，并传递了一些参数来启动zygote进程。
   service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote// 将此服务归类为主服务。class main// 设置此服务的优先级为-20，这是最高优先级，意味着这个服务将优先于其他服务运行。priority -20// 设置此服务的用户和组为root，同时给予了读取进程信息和访问保留磁盘的权限。user rootgroup root readproc reserved_disk// 创建了两个名为"zygote"和"usap_pool_primary"的socket，权限为660，所有者和组都是root和system。socket zygote stream 660 root systemsocket usap_pool_primary stream 660 root system// 定义了当服务重启时要执行的命令，包括执行一些命令、写入一些系统文件、重启一些服务等。onrestart exec_background - system system -- /system/bin/vdc volume abort_fuseonrestart write /sys/power/state on# NOTE: If the wakelock name here is changed, then also# update it in SystemSuspend.cpponrestart write /sys/power/wake_lock zygote_kwlonrestart restart audioserveronrestart restart cameraserveronrestart restart mediaonrestart restart media.tuneronrestart restart netdonrestart restart wificond// 设置了任务的性能配置文件。task_profiles ProcessCapacityHigh MaxPerformance// 设置了一个名为"zygote-fatal"的目标，当zygote进程在定义的窗口时间内崩溃时，将会触发这个目标。critical window=${zygote.critical_window.minute:-off} target=zygote-fatal
   

   总的来说，这个脚本定义了 zygote 服务的行为和属性，包括它如何启动，它的权限，它的优先级，以及当它重启时应该执行的操作。

十、总结

init 进程启动过程分为三个阶段：

• 第一阶段：主要工作是挂载分区，创建设备节点和一些关键目录，初始化日志输出系统，并启用 SELinux 安全策略。

• 第二阶段：主要工作是初始化属性系统，解析 SELinux 的策略文件，处理子进程终止信号，启动系统属性服务。每一项都是关键的。如果说第一阶段是为属性系统和 SELinux 做准备，那么第二阶段就是真正去实现这些功能。

• 第三阶段：主要是解析 init.rc 文件来启动其他进程，并进入一个无限循环，进行子进程的实时监控。

参考

• Android 10.0系统启动之init进程-[Android取经之路]