---
title: 'Android 啟動過程 - RC 檔案解析'
disqus: kyleAlien
---

Android 啟動過程 - RC 檔案解析
===

## OverView of Content

這個篇章專門描述 Rc 檔案的解析，如果要知道系統是在 何時開始分析 RC 檔案請看 [**系統啟動篇**](https://hackmd.io/pJpAeKAeRea0VIW3oI-mXw?view)

[TOC]

## 概述
在 init.cpp 檔案開始執行後，就會開始分析 rc 檔案

// /init/init.cpp

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

    ... 省略部分

    ActionManager& am = ActionManager::GetInstance();
    ServiceList& sm = ServiceList::GetInstance();


    // 從這裡開始分析
    LoadBootScripts(am, sm);

    ... 省略部分

}

### [init](https://cs.android.com/android/platform/superproject/+/master:system/core/init/init.cpp;l=1?q=init.cpp&sq=) - 讀取 init.rc 檔案

* 在上面的啟動流程中有提到會呼叫 **==LoadBootScripts== 函數，而就是這個函數來執行分析 init.rc 檔** (有多個 .rc 檔需要執行)

:::info
* init.rc 是一個相當重要的配置文件， `.rc` 是 Android 自身的語言。透過分析 init.rc 腳本來啟動不同的命令 (其他小節會說明 RC 語法)
:::

| rc 相關文件/路徑 | 功能 | 其它 |
| -------- | -------- | - |
| `/init.${ro.hardware}.rc` | 硬體廠商提供的主配置文件 | `/system/etc/init/hw/init.rc` |
| `/system/etc/init` | 核心系統模塊配置 | |
| `/vendor/etc/init` | 廠商提供的配置文件 | |
| `/odm/etc/init` | 設備製造商提供的配置文件 | |

    // /init/init.cpp 檔案

    static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
        
        // 創建解析器
        Parser parser = CreateParser(action_manager, service_list);
        
        // 取得 bootscript
        std::string bootscript = GetProperty("ro.boot.init_rc", "");
        
        if (bootscript.empty()) {
            
            // /system/etc/init/hw/init.rc 硬體廠商提供的主配置文件
            parser.ParseConfig("/system/etc/init/hw/init.rc");
            
            // /system/etc/init/ 用於核心系統項，例如 SurfaceFlinger、MediaService 和 logd。
            if (!parser.ParseConfig("/system/etc/init")) {
                late_import_paths.emplace_back("/system/etc/init");
            }
            // late_import is available only in Q and earlier release. As we don't
            // have system_ext in those versions, skip late_import for system_ext.
            parser.ParseConfig("/system_ext/etc/init");
            
            // /vendor/etc/init/ 
            // 用於 SoC 供應商項目，例如核心 SoC 功能所需的操作或守護進程。
            if (!parser.ParseConfig("/vendor/etc/init")) {
                late_import_paths.emplace_back("/vendor/etc/init");
            }
            
            // /odm/etc/init/ 
            // 用於設備製造商項目，例如運動傳感器或其他外圍功能所需的操作或守護程序。
            if (!parser.ParseConfig("/odm/etc/init")) {
                late_import_paths.emplace_back("/odm/etc/init");
            }
            if (!parser.ParseConfig("/product/etc/init")) {
                late_import_paths.emplace_back("/product/etc/init");
            }
        } else {
            
            // 開始解析 (一般走這裡)
            parser.ParseConfig(bootscript);
        }
    }

1. **創建解析器 CreateParser 物件**

        // /init/init.cpp 檔案

        Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {
            // 創建 Parser 物件
            Parser parser;

            // 分析 service & on & import

            // ServiceParser 解析 service
            parser.AddSectionParser("service", std::make_unique<ServiceParser>(
                                                       &service_list, GetSubcontext(), std::nullopt));

            // ActionParser 解析 on
            parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, GetSubcontext()));

            // ImportParser 解析 import
            parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
            return parser;
        }

2. 開始解析 rc 檔案: [**ParseConfig**](https://cs.android.com/android/platform/superproject/+/master:system/core/init/parser.cpp) 會分辨路徑是檔案還是資料夾，**最終都會都透 `ParseConfigFile` 函數分析**

        // /init/parser.cpp

        bool Parser::ParseConfig(const std::string& path) {

            // 判斷 path 是否為資料夾
            if (is_dir(path.c_str())) {

                // 解析資料夾，最終仍要調用 ParseConfigFile 函數
                return ParseConfigDir(path);
            }
            // @ 分析 ParseConfigFile 方法
            return ParseConfigFile(path);
        }


        // 解析資料夾並抓取需要檔案進行分析
        bool Parser::ParseConfigDir(const std::string& path) {

            LOG(INFO) << "Parsing directory " << path << "...";
            std::unique_ptr<DIR, decltype(&closedir)> config_dir(opendir(path.c_str()), closedir);

            if (!config_dir) {
                PLOG(INFO) << "Could not import directory '" << path << "'";
                return false;
            }
            
            dirent* current_file;
            std::vector<std::string> files;    /// 遞迴找到需要處理的文件，找到後放入 vector 對列

            while ((current_file = readdir(config_dir.get()))) {
                // Ignore directories and only process regular files.
                // 處理指定類型檔案
                if (current_file->d_type == DT_REG) {
                    std::string current_path =
                        android::base::StringPrintf("%s/%s", path.c_str(), current_file->d_name);
                    files.emplace_back(current_path);
                }
            }
            // Sort first so we load files in a consistent order (bug 31996208)
            std::sort(files.begin(), files.end());
            for (const auto& file : files) {
                // 將取得的檔案進行分析
                // @ 查看 ParseConfigFile
                if (!ParseConfigFile(file)) {
                    LOG(ERROR) << "could not import file '" << file << "'";
                }
            }
            return true;
        }

3. **ParseConfigFile 方法**：解析指定檔案

        // /init/parser.cpp

        // 解析指定檔案
        bool Parser::ParseConfigFile(const std::string& path) {
            LOG(INFO) << "Parsing file " << path << "...";
            android::base::Timer t;

            // 讀取路近的文件內容
            auto config_contents = ReadFile(path);
            if (!config_contents.ok()) {
                // 讀取失敗
                LOG(INFO) << "Unable to read config file '" << path << "': " << config_contents.error();
                return false;
            }


            // 解析獲取的字串
            // @ 追蹤 ParseData 方法
            ParseData(path, &config_contents.value());

            LOG(VERBOSE) << "(Parsing " << path << " took " << t << ".)";
            return true;
        }

### 解析 rc 文本 - [ParseData](https://cs.android.com/android/platform/superproject/+/master:system/core/init/parser.cpp)

* ParseData 透過判斷符號來解析 rc 文檔，

> 

    // /init/parser.cpp

    void Parser::ParseData(const std::string& filename, std::string* data) {
        data->push_back('\n');
        data->push_back('\0');
        parse_state state;
        state.line = 0;
        state.ptr = data->data();
        state.nexttoken = 0;
        SectionParser* section_parser = nullptr;
        int section_start_line = -1;
        std::vector<std::string> args;
        // If we encounter a bad section start, there is no valid parser object to parse the subsequent
        // sections, so we must suppress errors until the next valid section is found.
        bool bad_section_found = false;
        auto end_section = [&] {
            bad_section_found = false;
            if (section_parser == nullptr) return;
            if (auto result = section_parser->EndSection(); !result.ok()) {
                parse_error_count_++;
                LOG(ERROR) << filename << ": " << section_start_line << ": " << result.error();
            }
            section_parser = nullptr;
            section_start_line = -1;
        };

        for (;;) {
            switch (next_token(&state)) {

                // EOF 文件結束符號
                case T_EOF:
                    end_section();
                    for (const auto& [section_name, section_parser] : section_parsers_) {
                        section_parser->EndFile();
                    }
                    return;

                // 換行
                case T_NEWLINE: {
                    state.line++;
        
                    // 無參數返回
                    if (args.empty()) break;
                    // If we have a line matching a prefix we recognize, call its callback and unset any
                    // current section parsers.  This is meant for /sys/ and /dev/ line entries for
                    // uevent.
                    auto line_callback = std::find_if(
                        line_callbacks_.begin(), line_callbacks_.end(),
                        [&args](const auto& c) { return android::base::StartsWith(args[0], c.first); });

                    if (line_callback != line_callbacks_.end()) {
                        end_section();
                        if (auto result = line_callback->second(std::move(args)); !result.ok()) {
                            parse_error_count_++;
                            LOG(ERROR) << filename << ": " << state.line << ": " << result.error();
                        }

                    } else if (section_parsers_.count(args[0])) {    
                        // 分析 action、service
                        end_section();
                        section_parser = section_parsers_[args[0]].get();
                        section_start_line = state.line;

                        // 分析到 Section 
                        // @ 1. 追蹤 ParseSection 方法
                        if (auto result =
                                    section_parser->ParseSection(std::move(args), filename, state.line);
                            !result.ok()) {
                            parse_error_count_++;
                            LOG(ERROR) << filename << ": " << state.line << ": " << result.error();
                            section_parser = nullptr;
                            bad_section_found = true;
                        }
                    } else if (section_parser) {
                        // 分析 section 中的參數
                        // @ 2. 查看 ParseLineSection
                        if (auto result = section_parser->ParseLineSection(std::move(args), state.line);
                            !result.ok()) {
                            parse_error_count_++;
                            LOG(ERROR) << filename << ": " << state.line << ": " << result.error();
                        }
                    } else if (!bad_section_found) {
                        parse_error_count_++;
                        LOG(ERROR) << filename << ": " << state.line
                                   << ": Invalid section keyword found";
                    }
                    args.clear();
                    break;
                }
                case T_TEXT:
                    args.emplace_back(state.text);
                    break;
            }
        }
    }

### ParseSection 解析並創建 Service
* [**service_parser**](https://cs.android.com/android/platform/superproject/+/master:system/core/init/service_parser.cpp)#**ParseSection** 方法：分析 `init.rc` 檔案中的 Service 標籤，Service 必須參數，並創建 Service 對象

* 最後會在 Native 層創建 [**Service**](https://cs.android.com/android/platform/superproject/+/master:system/core/init/service.h) 對象，並保存到 **service_parser** 中

    // /init/service_parser.cpp

    Result<void> ServiceParser::ParseSection(
        std::vector<std::string>&& args,
        const std::string& filename, 
        int line) 
    {
        // 基礎要有三個以上的參數 service、name、path、options...
        if (args.size() < 3) {
            return Error() << "services must have a name and a program";
        }

        // 服務名稱
        const std::string& name = args[1];
        if (!IsValidName(name)) {
            return Error() << "invalid service name '" << name << "'";
        }
        filename_ = filename;
        Subcontext* restart_action_subcontext = nullptr;
        if (subcontext_ && subcontext_->PathMatchesSubcontext(filename)) {
            restart_action_subcontext = subcontext_;
        }

        // 取得參數
        std::vector<std::string> str_args(args.begin() + 2, args.end());

        // P & Q 版本有特殊的設置
        if (SelinuxGetVendorAndroidVersion() <= __ANDROID_API_P__) {
            if (str_args[0] == "/sbin/watchdogd") {
                str_args[0] = "/system/bin/watchdogd";
            }
        }
        if (SelinuxGetVendorAndroidVersion() <= __ANDROID_API_Q__) {
            if (str_args[0] == "/charger") {
                str_args[0] = "/system/bin/charger";
            }
        }

        // 創建 Service 對象
        service_ = std::make_unique<Service>(name, restart_action_subcontext, str_args, from_apex_);
        return {};
    }

### ParseLineSection 處理 section 參數 - 添加 Socket

* 舉例：以下為 Zygoto 啟動的 .rc 檔案，其中的 Section 就是 `priority`、`class`、`priority`、`user`、`socket`、`group` ... 等等

    # /rootdir/init.zygote64_32.rc

    # 1. Service Name = zygote
    # 2. Path = system/bin/app_process64，app_process64 是資料夾
    # 3. Argument:
        # -Xzygote /system/bin --zygote --start-system-server

    # 主 zygote
    service zygote /system/bin/app_process64     \
                -Xzygote /system/bin --zygote --start-system-server

        # 4. 分類為 main 群組
        class main

        priority -20
        user root
        group root readproc reserved_disk

        ## 啟動兩個 Socket，權限為 660
        socket zygote stream 660 root system
        socket usap_pool_primary stream 660 root system
        onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
        ...

* ParseLineSection 函數是用來解析 Section 中的參數，並在 Map 中尋找、執行它們對應的函數

    // service_parser.cpp

    Result<void> ServiceParser::ParseLineSection(std::vector<std::string>&& args, int line) {
        if (!service_) {
            return {};
        }

        // @ 查看 GetParserMap
        auto parser = GetParserMap().Find(args);    // 尋找 string 對應數據

        if (!parser.ok()) return parser.error();

        // 調用函數
        return std::invoke(*parser, this, std::move(args));
    }

* 該類中保存一個函數對照 Map 表 (`GetParserMap`)，其中就包含常見的 **Socket**

        // service_parser.cpp

        const KeywordMap<ServiceParser::OptionParser>& ServiceParser::GetParserMap() const {
            constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
            // clang-format off
            static const KeywordMap<ServiceParser::OptionParser> parser_map = {
                {"capabilities",            {0,     kMax, &ServiceParser::ParseCapabilities}},
                {"class",                   {1,     kMax, &ServiceParser::ParseClass}},
                {"console",                 {0,     1,    &ServiceParser::ParseConsole}},
                {"critical",                {0,     2,    &ServiceParser::ParseCritical}},
                {"disabled",                {0,     0,    &ServiceParser::ParseDisabled}},
                {"enter_namespace",         {2,     2,    &ServiceParser::ParseEnterNamespace}},
                {"file",                    {2,     2,    &ServiceParser::ParseFile}},
                {"group",                   {1,     NR_SVC_SUPP_GIDS + 1, &ServiceParser::ParseGroup}},
                {"interface",               {2,     2,    &ServiceParser::ParseInterface}},
                {"ioprio",                  {2,     2,    &ServiceParser::ParseIoprio}},
                {"keycodes",                {1,     kMax, &ServiceParser::ParseKeycodes}},
                {"memcg.limit_in_bytes",    {1,     1,    &ServiceParser::ParseMemcgLimitInBytes}},
                {"memcg.limit_percent",     {1,     1,    &ServiceParser::ParseMemcgLimitPercent}},
                {"memcg.limit_property",    {1,     1,    &ServiceParser::ParseMemcgLimitProperty}},
                {"memcg.soft_limit_in_bytes",
                                            {1,     1,    &ServiceParser::ParseMemcgSoftLimitInBytes}},
                {"memcg.swappiness",        {1,     1,    &ServiceParser::ParseMemcgSwappiness}},
                {"namespace",               {1,     2,    &ServiceParser::ParseNamespace}},
                {"oneshot",                 {0,     0,    &ServiceParser::ParseOneshot}},
                {"onrestart",               {1,     kMax, &ServiceParser::ParseOnrestart}},
                {"oom_score_adjust",        {1,     1,    &ServiceParser::ParseOomScoreAdjust}},
                {"override",                {0,     0,    &ServiceParser::ParseOverride}},
                {"priority",                {1,     1,    &ServiceParser::ParsePriority}},
                {"reboot_on_failure",       {1,     1,    &ServiceParser::ParseRebootOnFailure}},
                {"restart_period",          {1,     1,    &ServiceParser::ParseRestartPeriod}},
                {"rlimit",                  {3,     3,    &ServiceParser::ParseProcessRlimit}},
                {"seclabel",                {1,     1,    &ServiceParser::ParseSeclabel}},
                {"setenv",                  {2,     2,    &ServiceParser::ParseSetenv}},
                {"shutdown",                {1,     1,    &ServiceParser::ParseShutdown}},
                {"sigstop",                 {0,     0,    &ServiceParser::ParseSigstop}},
                
                // 查看 socket 對應函數 ParseSocket
                {"socket",                  {3,     6,    &ServiceParser::ParseSocket}},
                {"stdio_to_kmsg",           {0,     0,    &ServiceParser::ParseStdioToKmsg}},
                {"task_profiles",           {1,     kMax, &ServiceParser::ParseTaskProfiles}},
                {"timeout_period",          {1,     1,    &ServiceParser::ParseTimeoutPeriod}},
                {"updatable",               {0,     0,    &ServiceParser::ParseUpdatable}},
                {"user",                    {1,     1,    &ServiceParser::ParseUser}},
                {"writepid",                {1,     kMax, &ServiceParser::ParseWritepid}},
            };
            // clang-format on
            return parser_map;
        }

* **ParseSocket 函數**：創建 Socket 描述符，傳入 `ParseSocket` 的參數格式如 `name type perm [ uid gid context ]`

> 我們假設傳入的 String 為 `socket zygote stream 660 root system`

| 位置 | 參數 | Socket 儲存元素 | 其他 |
| - | -------- | -------- | -------- |
| [1] | zygote | `socket.name` | |
| [2] | stream | `socket.type` | 後面可使用 `+` 號串接其他設定 |
| [3] | 660 | `socket.perm` | perm 是權限 permission |
| [4] | root | `socket.uid` | |
| [5] | system | `socket.gid` | |

:::warning
* Socket 描述符在同一個服務中不可重複 !
:::

    // name type perm [ uid gid context ]
    Result<void> ServiceParser::ParseSocket(std::vector<std::string>&& args) {
        // 創建一個 Socket 檔案描述符號
        SocketDescriptor socket;
        socket.name = std::move(args[1]);    // 命名為 "socket"

        // 判斷第一個 type
        auto types = Split(args[2], "+");    // 使用 "+" 號區分
        if (types[0] == "stream") {
            socket.type = SOCK_STREAM;        // 設定該 Socket 類型

        } else if ...省略部分

        //循環處理第一個之後的 type 設定    (當前沒有... 可忽略
        for (size_t i = 1; i < types.size(); i++) {
            if (types[i] == "passcred") {
                socket.passcred = true;
            } else if (types[i] == "listen") {
                socket.listen = true;
            } else {
                ... 省略 err 提示
            }
        }

        errno = 0;
        char* end = nullptr;
        
        // 權限設定
        socket.perm = strtol(args[3].c_str(), &end, 8);

        ... 省略部分

        if (args.size() > 4) {
            auto uid = DecodeUid(args[4]);

            ... 省略錯誤

            socket.uid = *uid;
        }

        if (args.size() > 5) {
            auto gid = DecodeUid(args[5]);

            ... 省略錯誤

            socket.gid = *gid;
        }

        // 當前沒有
        socket.context = args.size() > 6 ? args[6] : "";

        auto old = std::find_if(service_->sockets_.begin(), service_->sockets_.end(),
                                [&socket](const auto& other) { return socket.name == other.name; });

        // 判斷是否重複 Socket 描述符
        if (old != service_->sockets_.end()) {
            return Error() << "duplicate socket descriptor '" << socket.name << "'";
        }

        // 儲存為 Service 中的 Socket
        service_->sockets_.emplace_back(std::move(socket));

        return {};
    }

到這裡 Service 就添加了一個 Socket (**尚未創建 ! 要等到 `Start` 函數才會創建**)
> 

## init.rc 語法
init.rc 語法主要可以透過兩個方式了解，^1^ [**Readme.txt**](https://android.googlesource.com/platform/system/core/+/master/init/README.md)、^2^ [**Init_parser.c**](https://android.googlesource.com/platform/system/core/+/android-4.2.2_r1.2/init/init_parser.c) (用來解析 init.rc 語法)，以下會說明幾個重點，若是還有問題應該要去看官方的 Readme 檔案

### rc 檔案 - 基礎規則
一個完整個 init.rc 腳本是由 **4 種類型的聲明組成**

| 關鍵字 | 概述 |
| -------- | -------- |
| Actions | 動作 |
| Commands | 命令 |
| Services | 服務 |
| Options | 選項 |

通用語法規則
1. 註釋使用 `#` 開頭
2. 關鍵字 與 參數用 `空格` 分隔，句以行為單位
3. 反向 `/` 可以用來為參數添加空格
4. 如果有字符串（並且該字符串中有空格），必須使用 `雙引號` 將其包含在內
5. 在尾端添加 `/` 是代表與下一行，同行 (如同 C 語言)
6. Actions 與 Services 暗示著新語句的開始，這兩個關鍵字後面跟著 commands 或是 options 則都是屬於這個新語句的
7. **Actions 與 Services 有唯一的名子**，若有重名，則會當成 `錯誤忽略掉`

### Actions - on 動作

* 一個 Action 就是響應事件的流程，**只要發現符合條件的 Actions 就會把它加入命令執行列隊的尾部（依照順序執行 cmd）**，而系統則會依序執行 cmd

    # Action 格式

    on <trigger> # 觸發條件
       <command1> # 觸發後執行的命令
       <command2> # 可執行多個命令
       <command3> 
       ...

* Action 會配合著 `on` 使用，`on` 代表這著 trigger 的時機(條件)

| 常見配合 on 指令 | 說明 |
| -------- | -------- |
| on `early-init` | 在 init 之前執行 |
| on `init` | 在 init 時執行 |
| on `late-init` | 在 init 之後執行 |
| on `boot/charger` | 在系統啟動 or 充電 or 其他情況時被觸發 (下面列表會舉幾個常見的) |
| on `property` | 當滿足某個條件時 |

> 

* 以下列出幾個 Actions 常見的事件

| Trigger | Describe |
| -------- | -------- |
| boot | init 程序啟動後觸發的第一個事件 |
| <name\>=<value\> | 像是 if/else 的判斷，當 name 滿足了 value 的設定時就會被觸發 |
| device-added-<path\> | 當設備添加節點時，觸發事件 |
| device-removed-<path\> | 當設備移除節點時，觸發事件 |
| service-exited-<name\> | 當指定服務 name 存在時，觸發事件 |

### Action Commands - 命令
* **每個 Action 都會有不同的 Command 控制**，命令將會在所屬的 Actions 發生時一個個的執行，這些命另有一些跟 Linux cmd 很像，所以可讀性較高

| Command | 描述 | 備註 |
| -------- | -------- | -------- |
| exec <path\> [<argument\>]* | Fork 並執行一個程序，該程序路徑為 path | 該指令會造成 init 進程 **堵塞** |
| **exprot** <name\> <value\> | 設定環境變量，<name\> 的值為 <value\> | **對全局有效，之後的所有進程都會繼承該變量** |
| ifup <interface\> | 使網路接口 interface 成功連結 | |
| import <filename\> | 解析令一個配置文件，文件名為 filename | 拓展當前配置 |
| hostname <name\> | 設定主機名 <name\> | |
| chdir <directory\> | 更改工作目錄為 <chdir\> | change |
| chmod <octal-mode\> <path\> | 同 Linux，改變文件訪問權限 | |
| chown <owner\> <group\> <path\> | 改變所有者 ＆ 群組 | [**文件權限-ch**](https://hackmd.io/MtOap5UaR7KcJpdTisc75g?view#%E6%96%87%E4%BB%B6%E6%AC%8A%E9%99%90-ch) |
| chroot <directory\> | 更改根目錄位置 | |
| class_start <serviceclass\> | 啟動由 <serviceclass\> 類名所指定的所有相關服務，也就是啟動 **多個服務** | 若已經啟動的則不管 |
| class_stop <serviceclass\> | 同上，只是改為停止 | 若尚未啟動的則不管 |
| domainname <path\> | 設定域名 | |
| insmod <path\> | 在 <path\> 路徑上安裝一個模塊 | |
| mkdir <path\> [mode] [owner] [group] | 在 <path\> 路徑上安裝一個目錄 | |
| mount <type\> <device\> <dir\> [<mountoptions\>]* | 嘗試是一個路徑上掛載設備 | |
| setprop <name\> <value\> | 設定系統屬性 | property |
| setrlimit <resource\> <cur\> <max\> | 限定資源的使用，<cur\> 是軟限制，<max\> 是硬限制 | set resource limit |
| start <service\> | 啟動單一個服務 | 若已啟動則不管 |
| stop <service\> | 停止單一個服務 | 若已停止則不管 |
| syslink <target\> <path\> | 創建一個 <path\> 路徑的連結，該連結目標為 <target\> | 像是點擊 path 會跳置 target |
| sysclktz <mins_west_of_gmt> | 設定基準時間 | 若當前時間是 GMT，這個值為 0 |
| trgger <event\> | 觸發一個事件 | |
| write <path\> <string\> [<string\>]* | 打開 path 路徑的文件，寫入字串 | 就是 IO 操作 |

### Services - 服務

* Services 其實是可執行程序，在一些約束下會被 init 程序 `運行` or `重起` (Service 可以再配至中指定是否需要退出時重起，這樣當 Serviced 出現異常 crush 時就有機會復原)

* **Service 一般運行在 init 的子進程 (通過 fork 的方式生成子進程)**，所以啟動 Service 前需要判斷對應的可執行文件是否存在

    # Services 格式

    # name： service 名稱
    # pathname： service 所在路徑
    # argument： service 所需參數
    # option： 對 service 的約束控制
    service <name> <pathname> [<argument>]*
        <option1>
        <option2>
        <option3>
        ...

### Service Options

* Option 對 service 的約束控制，針對 Options 說明幾個命令

| Options | 描述 | 備註 |
| -------- | -------- | -------- |
| critical | 當一個設備在 4 分鐘內退出超過 4 次，則重起進入恢復模式 | 危急 |
| disabled | 服務不會自動啟動，而通過顯示調用服務名，才會啟動 | |
| setenv <name\> <value\> | 設定環境變量 <name\> 為 <value\> 值 | |
| socket <name\> <type\> <perm\> [<user\>[<group\>]] | 創建一個名為 /dev/socket/<name\> 的 unix domain socket，並將其 fd 值傳給啟動它的進程 | 有效的 <type\> 包括 dgram、stream、seqpacket，user 跟 group 默認為 0 |
| user <username\> | 啟動服務前將用戶切換到指定 user | 默認為 root |
| group <groupname\> [<groupname\>]* | 啟動服務前將用戶切換到指定 groupname | |
| oneshot | 當服務退出時，不主動重起 | |
| class <name\> | 為該服務指定 class 名稱 | **同一個 class 的服務必須同時停止 or 啟動**，默認 class 名為 default |
| onrestart | 當服務重起時，執行指定命令 | |

:::success
* **Actions vs. Service 差異**
1. Actions 是有必須條件才會觸發命令; Service 是一定執行命令，並且是通過 Options 限制條件

2. Actions 創建需要的目錄並給定權限; Service 用來啟動子進程服務
:::

### import - 加載其他 rc 檔案

* import 是一個關鍵字，不是命令，**用來加載其他 `.rc` 文件，或是加載一個 `資料夾`**（如果是一個資料夾，那所有文件都會被導入）

    import path

:::info
不會循環加載
:::

## [init.rc](https://cs.android.com/android/platform/superproject/+/master:system/core/rootdir/init.rc) 分析

以下為 `init.rc` 檔案片段

1. import 關鍵字引入其他 `.rc` 文件

2. Action 設定 `early-init`、`init`、`boot`... 代表它們要啟動的時機

    # /rootdir/init.rc

    import /init.environ.rc
    import /system/etc/init/hw/init.usb.rc
    import /init.${ro.hardware}.rc
    import /vendor/etc/init/hw/init.${ro.hardware}.rc
    import /system/etc/init/hw/init.usb.configfs.rc
    import /system/etc/init/hw/init.${ro.zygote}.rc

    on early-init
        # Disable sysrq from keyboard
        write /proc/sys/kernel/sysrq 0

        # Android doesn't need kernel module autoloading, and it causes SELinux
        # denials.  So disable it by setting modprobe to the empty string.  Note: to
        # explicitly set a sysctl to an empty string, a trailing newline is needed.
        write /proc/sys/kernel/modprobe \n

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

        ...

    on init
        sysclktz 0

        # Mix device-specific information into the entropy pool
        copy /proc/cmdline /dev/urandom
        copy /system/etc/prop.default /dev/urandom

        ...


    on boot
        # basic network init
        ifup lo                # 連接網路接口
        hostname localhost    # 設定 hostname
        domainname localdomain    # 設定 domainname

        # IPsec SA default expiration length
        write /proc/sys/net/core/xfrm_acq_expires 3600    # 對 /proc/sys/net/core/xfrm_acq_expires 文件寫入 3600 字串

        ...
        # System server manages zram writeback
        chown root system /sys/block/zram0/idle    # 改變文件所有者為 root
        chmod 0664 /sys/block/zram0/idle            # 改變文件權限為 0664
        chown root system /sys/block/zram0/writeback
        chmod 0664 /sys/block/zram0/writeback

        ...

        # Define default initial receive window size in segments.
        setprop net.tcp_def_init_rwnd 60    # 設定 net.tcp_def_init_rwnd 的屬性

        # Start standard binderized HAL daemons
        class_start hal                    # 啟動所有標誌為 hal 的服務進程
        class_start core                   # 啟動所有標誌為 core 的服務進程

        ...

        # Actions
        on nonencrypted
        class_start main            # 符合 nonencrypted 條件則啟動 main 相關服務
        class_start late_start

        ...

        # Services 匿名內存共享
        service ueventd /system/bin/ueventd    # 啟動 ueventd 服務進程
        class core    # 啟動 core 服務進程
        critical        # 若失敗 4 次以上，進入恢復狀態
        seclabel u:r:ueventd:s0
        shutdown critical

### 啟動 Service 服務進程

# /rootdir/init.rc 檔案

on boot
    # Actions
    on nonencrypted
    
    # class_start 是一個命令，對應到 builtins.cpp#do_class_start
    class_start main            
    class_start late_start

    ...
    

* class_start 是一個命令，對應到 [**builtins**](https://cs.android.com/android/platform/superproject/+/master:system/core/init/;bpv=0;bpt=1)#do_class_start 函數：該函數會透過 `StartIfNotDisabled` 方法 啟動 class

    // /init/builtins.cpp

    static Result<void> do_class_start(const BuiltinArguments& args) {
        // Do not start a class if it has a property persist.dont_start_class.CLASS set to 1.
        if (android::base::GetBoolProperty("persist.init.dont_start_class." + args[1], false))
            return {};
        // Starting a class does not start services which are explicitly disabled.
        // They must  be started individually.
        for (const auto& service : ServiceList::GetInstance()) {
            if (service->classnames().count(args[1])) {
                // 判斷該 Service 是否可以啟動，可以的話就啟動
                if (auto result = service->StartIfNotDisabled(); !result.ok()) {
                    LOG(ERROR) << "Could not start service '" << service->name()
                               << "' as part of class '" << args[1] << "': " << result.error();
                }
            }
        }
        return {};
    }

* C++ 啟動 Service 的過程如下：創建必要 Socket，再來主要是透過 `fork` + `exec` SystemCall 在 init 進程開啟一個新進程

    // /init/service.cpp

    Result<void> Service::StartIfNotDisabled() {

        // 判斷是否 Disable
        if (!(flags_ & SVC_DISABLED)) {
            return Start();
        } else {
            flags_ |= SVC_DISABLED_START;
        }
        return {};
    }


    Result<void> Service::Start() {
        ... 省略部分判斷

        pid_t pid = -1;
        if (namespaces_.flags) {
            pid = clone(nullptr, nullptr, namespaces_.flags | SIGCHLD, nullptr);
        } else {
            // 使用 fork 創建子進程
            pid = fork();
        }
        
        
        std::vector<Descriptor> descriptors;
        for (const auto& socket : sockets_) {
            // 透過 Create 函數創建 Socket 物件
            if (auto result = socket.Create(scon); result.ok()) {
                descriptors.emplace_back(std::move(*result));
            } else {
                LOG(INFO) << "Could not create socket '" << socket.name << "': " << result.error();
            }
        }


        ... 省略部分

        if (pid == 0) {
            umask(077);

            ... 省略部分

            // 執行 ececv 函數，並啟動 Service 子進程
            if (!ExpandArgsAndExecv(args_, sigstop_)) {
                PLOG(ERROR) << "cannot execv('" << args_[0]
                            << "'). See the 'Debugging init' section of init's README.md for tips";
            }
            _exit(127);
        }

    }

    static bool ExpandArgsAndExecv(const std::vector<std::string>& args, bool sigstop) {

        // 收集參數 & Service 名稱
        std::vector<std::string> expanded_args;
        std::vector<char*> c_strings;
        expanded_args.resize(args.size());
        c_strings.push_back(const_cast<char*>(args[0].data()));
        for (std::size_t i = 1; i < args.size(); ++i) {
            auto expanded_arg = ExpandProps(args[i]);
            if (!expanded_arg.ok()) {
                LOG(FATAL) << args[0] << ": cannot expand arguments': " << expanded_arg.error();
            }
            expanded_args[i] = *expanded_arg;
            c_strings.push_back(expanded_args[i].data());
        }
        c_strings.push_back(nullptr);
        if (sigstop) {
            kill(getpid(), SIGSTOP);
        }

        // 啟動服務
        return execv(c_strings[0], c_strings.data()) == 0;
    }

:::success
* **fork + execv**

從上面可以看出透過分析 init.rc 檔案，會透過 `fork` + `execv` 複製 init 進程並啟動多個不同進程，並不只有我們常見的 `ServiceManager`、`Zygote`... 等等
:::

## 透過 init.rc 啟動的服務
從上面我們知道 init 進程 透過分析 init.rc 來達成啟動不同服務，那我們就來看看它啟動了哪些重點服務

### ServiceManager 服務

* 從 [**init.rc**](https://android.googlesource.com/platform/system/core/+/master/rootdir/init.rc#448) 的 `on init` action 可以看到它最後啟動了 ServiceManager 服務進程，而啟動 ServiceManager 會先啟動到 [**servicemanager.rc**](https://android.googlesource.com/platform/frameworks/native/+/master/cmds/servicemanager/servicemanager.rc) (真正啟動服務)

    # /rootdir/init.rc 檔案

    on init
        ...    
        # Start essential services.    # essential 基礎
        start servicemanager    # 啟動 srvicemanager.rc
        start hwservicemanager
        start vndservicemanager
    
    # -----------------------------------------------------------------------

    # /cmds/servicemanager/servicemanager.rc
    # service 格式：service <name> <pathname>
    
    service servicemanager /system/bin/servicemanager    # 啟動 servicemanager
        class core animation        # 所屬的 class 為 animation
        user system
        group system readproc
        
        critical    # 若失敗 4 次則進入恢復模式
        
        onrestart restart apexd    # 若重新啟動則需要 重起以下服務
        onrestart restart audioserver
        onrestart restart gatekeeperd
        onrestart class_restart main
        onrestart class_restart hal
        onrestart class_restart early_hal
        writepid /dev/cpuset/system-background/tasks
        shutdown critical

* ServiceManager 有設定 class（animation 組），也就是說若停止 animation 組，那其他有關的 animation 組都會停止

* ServiceManager 重新啟動時，`apexd`、`audioserver`、`gatekeeperd`、`main`、`hal`、`early_hal` 都會重新啟動
> 

### Zygote 服務
1. Zygote 啟動在 **`late-init` 時** (init 進程會決定要不要觸發 late-init)

    # /rootdir/init.rc

    on late-init
        trigger early-fs
        trigger fs
        trigger post-fs
        trigger late-fs
        trigger post-fs-dataograms


        trigger zygote-start # 觸發 zygote-start 相關的 on


        trigger firmware_mounts_complete
        trigger early-boot
        trigger boot

2. 觸發 `zygote-start` 相關的 `on`：on 底下有一個 start 關鍵字，是用來啟動指定 service，而 `zygote-start` 就是啟動以下兩個服務
* zygote (主要)
* zygote_secondary (備用)

    # /rootdir/init.rc

    on zygote-start && property:ro.crypto.state=unencrypted
        wait_for_prop odsign.verification.done 1
        # A/B update verifier that marks a successful boot.
        exec_start update_verifier_nonencrypted
        start statsd
        start netd
        start zygote
        start zygote_secondary

    on zygote-start && property:ro.crypto.state=unsupported
        wait_for_prop odsign.verification.done 1
        # A/B update verifier that marks a successful boot.
        exec_start update_verifier_nonencrypted
        start statsd
        start netd
        start zygote
        start zygote_secondary

    on zygote-start && property:ro.crypto.state=encrypted && property:ro.crypto.type=file
        wait_for_prop odsign.verification.done 1
        # A/B update verifier that marks a successful boot.
        exec_start update_verifier_nonencrypted
        start statsd
        start netd
        start zygote
        start zygote_secondary

> 

## Zygote 相關 rc 檔案

1. 從 [**init.rc**](https://android.googlesource.com/platform/system/core/+/master/rootdir/init.rc) 開始看，在開頭可以看到 Zygote 設定檔被 import 進來

    // /rootdir/init.rc

    import /init.${ro.hardware}.rc    # 硬體是 32 or 64 位元
    import /system/etc/init/hw/init.${ro.zygote}.rc

2. **從 ++硬體設置++ 來決定要引用哪個 `init.zygote.rc` 檔案**，以下用 `init.zygote64_32.rc` 為例，init 進程就會啟動兩個 Zytoge 進程 (主要、備用)

> 

:::info
* **若是 zygote32_64、zygote64_32 則會啟動++兩個 Zygote 進程++**，前面那個就是主要 zygote，後面的則是 zygote_secondary

> ex. zygote32_64、zygote 就是 32 bit、zygote_secondary 就是 64 bit
:::

### init.zygote64_32.rc
* 透過 init 進程對 service 的分析，就可以知道 `zygote64_32` 會 `fork` init 進程並 `execv` 啟動兩個服務
1. **zygote** 服務：路徑 `/system/bin/app_process64`

2. **zygote_secondary** 服務：路徑 `/system/bin/app_process32`

    # /rootdir/init.zygote64_32.rc

    # 1. Service Name = zygote
    # 2. Path = system/bin/app_process64，app_process64 是資料夾
    # 3. Argument:
        # -Xzygote /system/bin --zygote --start-system-server

    # 主 Socket
    service zygote /system/bin/app_process64     \
                -Xzygote /system/bin --zygote --start-system-server

        # 4. 分類為 main 群組
        class main

        priority -20
        user root
        group root readproc reserved_disk
        socket zygote stream 660 root system
        socket usap_pool_primary stream 660 root system
        onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
        ...

    # zygote_secondary 為輔助
    service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
        class main
        priority -20
        user root
        group root readproc reserved_disk
        socket zygote_secondary stream 660 root system
        socket usap_pool_secondary stream 660 root system
        onrestart restart zygote
        task_profiles ProcessCapacityHigh MaxPerformance

> 其他相關 rc 檔案就不再多舉例

## Appendix & FAQ

:::info
:::

###### tags: `Android 系統`