第4章：Init进程与系统启动

kernel_init() -> run_init_process("/init") -> execve("/init")

PATH=/system/bin:/system/xbin:/vendor/bin:/odm/bin
LD_LIBRARY_PATH=/system/lib64:/vendor/lib64:/odm/lib64
ANDROID_ROOT=/system
ANDROID_DATA=/data
ANDROID_STORAGE=/storage
ANDROID_RUNTIME_ROOT=/apex/com.android.runtime
ANDROID_TZDATA_ROOT=/apex/com.android.tzdata
ANDROID_ART_ROOT=/apex/com.android.art
BOOTCLASSPATH=/apex/com.android.runtime/javalib/core-oj.jar:...

struct Action {
    std::string name;
    std::vector<Command> commands;
    std::map<std::string, std::string> property_triggers;
    std::string event_trigger;
    bool oneshot;
    int trigger_order;  // 触发优先级

    // 执行状态管理
    size_t current_command;
    bool ExecuteOneCommand();
    bool CheckPropertyTriggers();

    // 触发器管理
    std::set<std::string> required_property_contexts;
    bool TriggersEqual(const Action& other) const;

    // 执行控制
    std::chrono::steady_clock::time_point last_command_time;
    std::optional<std::chrono::milliseconds> command_timeout;
}

struct Service {
    std::string name;
    unsigned flags;  // SVC_RUNNING, SVC_DISABLED, SVC_RESTARTING等
    pid_t pid;
    std::vector<std::string> args;
    std::vector<Option> options;

    // 服务控制
    int crash_count;
    time_t time_started;
    time_t time_crashed;
    std::chrono::seconds restart_period = 5s;  // 重启间隔
    std::optional<std::chrono::seconds> timeout_period;  // 启动超时

    // 进程管理
    std::optional<std::string> console;  // 控制台设备
    std::optional<bool> sigstop;  // 启动后是否暂停
    std::vector<std::pair<int, rlimit>> rlimits;  // 资源限制
    std::vector<std::string> writepid_files;  // PID文件路径

    // 安全上下文
    std::string seclabel;  // SELinux标签
    std::vector<uid_t> supp_gids;  // 补充组ID
    CapSet capabilities;  // Linux capabilities
    std::optional<std::vector<std::string>> updatable;  // APEX更新

    // 命名空间隔离
    unsigned namespace_flags;  // CLONE_NEWPID, CLONE_NEWNET等
    std::vector<std::string> namespaces_to_enter;  // 进入已存在的namespace

    // cgroup和调度
    std::map<std::string, std::string> cgroup_paths;
    int oom_score_adjust = -1000;  // OOM killer调整值
    int priority = 0;  // nice值
    struct sched_param scheduling_param;  // 实时调度参数

    // 服务依赖
    std::set<std::string> before_services;  // 必须在这些服务前启动
    std::set<std::string> after_services;   // 必须在这些服务后启动

    // 关键服务处理
    bool is_critical = false;  // 崩溃是否触发重启
    std::vector<std::string> critical_services_to_restart;
}

// 属性存储结构
struct prop_info {
    atomic_uint_least32_t serial;  // 版本号，用于检测变化
    char value[PROP_VALUE_MAX];   // 属性值（92字节）
    char name[PROP_NAME_MAX];     // 属性名（32字节）
};

// 属性区域管理
struct prop_area {
    uint32_t bytes_used;
    atomic_uint_least32_t serial;  // 全局版本号
    uint32_t magic;  // 0x504f5250 ('PROP')
    uint32_t version;  // 当前版本号
    uint32_t reserved[4];
    char data[0];  // 实际属性数据
};

// 属性节点（Trie树结构）
struct prop_bt {
    uint32_t namelen;  // 名称长度
    uint32_t proplen;  // 属性数量
    uint32_t children;  // 子节点偏移
    uint32_t props;  // 属性列表偏移
    char name[0];  // 节点名称
};

// 属性上下文映射
struct prop_context {
    const char* name_prefix;  // 属性前缀
    const char* context;  // SELinux上下文
    bool exact_match;  // 是否精确匹配
};

class BuiltinFunctionMap {
    std::map<std::string, BuiltinFunction> functions_;

    // 注册的内置命令
    void RegisterBuiltinFunctions() {
        // 文件系统操作
        Register("chmod", do_chmod);
        Register("chown", do_chown);
        Register("copy", do_copy);
        Register("mkdir", do_mkdir);
        Register("mount", do_mount);
        Register("umount", do_umount);
        Register("symlink", do_symlink);
        Register("rm", do_rm);
        Register("rmdir", do_rmdir);
        Register("write", do_write);

        // 服务控制
        Register("class_start", do_class_start);
        Register("class_stop", do_class_stop);
        Register("class_reset", do_class_reset);
        Register("start", do_start);
        Register("stop", do_stop);
        Register("restart", do_restart);
        Register("enable", do_enable);

        // 属性操作
        Register("setprop", do_setprop);
        Register("getprop", do_getprop);
        Register("wait_for_prop", do_wait_for_prop);

        // 进程执行
        Register("exec", do_exec);
        Register("exec_start", do_exec_start);
        Register("exec_background", do_exec_background);

        // 触发器管理
        Register("trigger", do_trigger);

        // 系统控制
        Register("bootchart", do_bootchart);
        Register("init_user0", do_init_user0);
        Register("installkey", do_installkey);
        Register("load_persist_props", do_load_persist_props);

        // 网络配置
        Register("hostname", do_hostname);
        Register("domainname", do_domainname);
        Register("ifup", do_ifup);

        // 安全相关
        Register("restorecon", do_restorecon);
        Register("restorecon_recursive", do_restorecon_recursive);
        Register("setrlimit", do_setrlimit);
        Register("swapon_all", do_swapon_all);

        // 日志和调试
        Register("loglevel", do_loglevel);
        Register("mark_post_data", do_mark_post_data);
    }

    // 命令执行包装
    Result<Success> Execute(const std::string& name, 
                           const std::vector<std::string>& args) {
        auto it = functions_.find(name);
        if (it == functions_.end()) {
            return Error() << "Unknown command: " << name;
        }
        return it->second(args);
    }
};

class Epoll {
private:
    int epoll_fd_;
    std::map<int, std::function<void()>> handlers_;

public:
    void Open() {
        // 创建epoll实例，EPOLL_CLOEXEC防止fd泄露到子进程
        epoll_fd_ = epoll_create1(EPOLL_CLOEXEC);
        if (epoll_fd_ == -1) {
            PLOG(FATAL) << "epoll_create1 failed";
        }

        // 注册信号处理（使用signalfd）
        sigset_t mask;
        sigemptyset(&mask);
        sigaddset(&mask, SIGCHLD);
        sigaddset(&mask, SIGTERM);
        signal_fd_ = signalfd(-1, &mask, SFD_CLOEXEC);
        RegisterHandler(signal_fd_, HandleSignals);

        // 注册属性服务
        property_fd_ = CreatePropertySocket();
        RegisterHandler(property_fd_, HandlePropertySet);

        // 注册控制消息
        init_fd_ = CreateInitSocket();
        RegisterHandler(init_fd_, HandleInitSocket);

        // 注册keychord（组合键）
        keychord_fd_ = OpenKeychordDevice();
        if (keychord_fd_ >= 0) {
            RegisterHandler(keychord_fd_, HandleKeychord);
        }
    }

    void RegisterHandler(int fd, std::function<void()> handler) {
        epoll_event ev = {};
        ev.events = EPOLLIN;  // 监听可读事件
        ev.data.fd = fd;

        if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &ev) == -1) {
            PLOG(ERROR) << "Failed to add fd " << fd << " to epoll";
            return;
        }

        handlers_[fd] = std::move(handler);
    }

    std::optional<std::function<void()>> Wait(
            std::optional<std::chrono::milliseconds> timeout) {
        epoll_event events[32];
        int timeout_ms = -1;

        if (timeout.has_value()) {
            timeout_ms = timeout->count();
        }

        int nr = epoll_wait(epoll_fd_, events, 
                           arraysize(events), timeout_ms);

        if (nr == -1) {
            PLOG(ERROR) << "epoll_wait failed";
            return std::nullopt;
        }

        for (int i = 0; i < nr; i++) {
            auto it = handlers_.find(events[i].data.fd);
            if (it != handlers_.end()) {
                return it->second;
            }
        }

        return std::nullopt;
    }
};

int main() {
    // ... 初始化代码 ...

    while (true) {
        // 1. 执行待处理的Actions
        if (!ActionQueue.empty()) {
            auto action = ActionQueue.front();
            action->ExecuteOneCommand();
            if (action->IsCompleted()) {
                ActionQueue.pop();
            }
        }

        // 2. 检查需要重启的服务
        for (auto& service : ServiceList) {
            if (service.flags & SVC_RESTARTING) {
                if (CurrentTime() > service.time_crashed + 
                    service.restart_period) {
                    service.Start();
                }
            }
        }

        // 3. 计算超时时间
        int timeout = -1;  // 默认无限等待
        if (!ActionQueue.empty()) {
            timeout = 0;  // 有待处理命令，立即返回
        } else if (HasRestartingServices()) {
            timeout = CalculateRestartTimeout();
        }

        // 4. 等待事件
        epoll_event events[32];
        int nr = epoll_wait(epoll_fd, events, 32, timeout);

        // 5. 处理事件
        for (int i = 0; i < nr; i++) {
            auto handler = handlers_[events[i].data.fd];
            handler();
        }
    }
}

void HandleSignals() {
    signalfd_siginfo info;
    read(signal_fd, &info, sizeof(info));

    switch (info.ssi_signo) {
        case SIGCHLD:
            ReapChildren();
            break;
        case SIGTERM:
        case SIGINT:
            HandleShutdown();
            break;
        case SIGUSR1:
            HandleBootchart();
            break;
    }
}

void ReapChildren() {
    while (true) {
        int status;
        pid_t pid = waitpid(-1, &status, WNOHANG);
        if (pid <= 0) break;

        Service* service = FindServiceByPid(pid);
        if (service) {
            service->Reap(status);
            if (service->flags & SVC_CRITICAL) {
                // 关键服务崩溃，可能触发重启
                HandleCriticalCrash(service);
            }
        }
    }
}

iOS launchd plist:
<dict>
    <key>Label</key>
    <string>com.apple.service</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/service</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
</dict>

Android RC:
service apple_service /system/bin/service
    class core
    user system
    group system

// 鸿蒙服务配置
{
    "services": [{
        "name": "distributed_service",
        "path": "/system/bin/d_service",
        "distributed": true,
        "capability": ["ohos.permission.DISTRIBUTED_DATA"],
        "devices": ["phone", "tablet", "tv"]
    }]
}

on <trigger> [&& <trigger>]*
    <command>
    <command>
    ...

# 早期初始化
on early-init
    start ueventd
    mkdir /mnt/vendor/persist 0771 root system

# 属性触发器
on property:sys.boot_completed=1
    setprop sys.runtime.firstboot.end ${ro.runtime.firstboot.end}
    exec_background - system system -- /system/bin/bootstat --record_boot_complete

# 多条件触发器
on property:vold.decrypt=trigger_restart_framework && property:ro.crypto.type=file
    class_start main
    class_start late_start

service <name> <pathname> [ <argument> ]*
    <option>
    <option>
    ...

# 基础服务示例
service servicemanager /system/bin/servicemanager
    class core animation
    user system
    group system readproc
    critical
    onrestart restart apexd
    onrestart restart audioserver
    onrestart restart gatekeeperd
    onrestart class_restart main
    writepid /dev/cpuset/system-background/tasks

# 厂商服务示例（小米）
service mi_thermald /system/bin/mi_thermald
    class main
    user system
    group system
    capabilities SYS_NICE NET_ADMIN
    socket mi_thermald stream 0660 system system

# 静态导入
import /init.${ro.hardware}.rc
import /vendor/etc/init/hw/init.${ro.hardware}.rc
import /system/etc/init/hw/init.${ro.zygote}.rc

# 动态导入（基于属性）
import /init.recovery.${ro.hardware}.rc

# 精确匹配
on property:persist.sys.language=zh-CN
    setprop persist.sys.locale zh-CN

# 通配符匹配
on property:sys.boot_from_charger_mode=1
    trigger late-init

# 多属性组合
on property:ro.crypto.state=encrypted && property:ro.crypto.type=file
    start vold_decrypt

# 定义触发器
on enable-logging
    start logd
    start logd-reinit

# 触发自定义触发器
on boot
    trigger enable-logging

class Parser {
    std::map<std::string, std::unique_ptr<SectionParser>> parsers_;

    void AddSectionParser(const std::string& name, 
                         std::unique_ptr<SectionParser> parser) {
        parsers_[name] = std::move(parser);
    }

    void ParseData(const std::string& data) {
        Tokenizer tokenizer(data);
        while (tokenizer.HasMore()) {
            auto tokens = tokenizer.GetLine();
            if (IsSectionStart(tokens[0])) {
                current_parser_ = parsers_[tokens[0]];
            }
            current_parser_->ParseLine(tokens);
        }
    }
};

// 将文本分解为Token，处理引号、转义字符
std::vector<std::string> Tokenizer::GetLine() {
    // 跳过空白和注释
    SkipWhitespace();
    if (current_ == '#') SkipToNextLine();

    // 解析token
    while (!IsEndOfLine()) {
        if (current_ == '"') {
            tokens.push_back(ParseQuotedString());
        } else {
            tokens.push_back(ParseWord());
        }
    }
}

class ActionParser : public SectionParser {
    void ParseSection(std::vector<std::string>& args) {
        // "on" <trigger> [&& <trigger>]*
        auto action = std::make_unique<Action>();
        for (size_t i = 1; i < args.size(); i++) {
            if (args[i] == "&&") continue;
            action->AddTrigger(args[i]);
        }
    }

    void ParseLine(std::vector<std::string>& args) {
        // 解析命令
        auto cmd = Command(args[0], args.begin() + 1, args.end());
        current_action_->AddCommand(cmd);
    }
};

bool Service::ParseLine(const std::vector<std::string>& args) {
    static const OptionParserMap option_parsers = {
        {"class", ParseClass},
        {"user", ParseUser},
        {"group", ParseGroup},
        {"capabilities", ParseCapabilities},
        {"seclabel", ParseSeclabel},
        {"oneshot", ParseOneshot},
        {"disabled", ParseDisabled},
        // ... 更多选项
    };

    auto parser = option_parsers.find(args[0]);
    if (parser == option_parsers.end()) {
        return Error("Invalid option: " + args[0]);
    }
    return parser->second(args);
}

// 属性值替换
std::string ExpandProps(const std::string& src) {
    // ${property_name} -> property_value
    // ${property_name:-default} -> 带默认值
    std::regex prop_regex(R"(\$\{([^}]+)\})");
    return std::regex_replace(src, prop_regex, 
        [](const std::smatch& match) {
            return GetProperty(match[1].str());
        });
}

// 条件导入
if (android::base::GetBoolProperty("ro.debuggable", false)) {
    ParseConfig("/system/etc/init/debug.rc");
}

1. 检查内核是否支持SELinux
2. 从/system、/vendor等分区读取策略文件
3. 编译并加载到内核
4. 设置enforcing模式

service critical_service /system/bin/critical
    class core
    priority -20

service normal_service /system/bin/normal
    class late_start
    after critical_service