int main(int argc, char** argv) {
#if __has_feature(address_sanitizer)
    __asan_set_error_report_callback(AsanReportCallback);
#endif
    if (!strcmp(basename(argv[0]), "ueventd")) {
        return ueventd_main(argc, argv);//uevent的初始化
    if (argc > 1) {
        if (!strcmp(argv[1], "subcontext")) {
            android::base::Initialling(argv, &android::base::KernelLogger);
            const BuiltinFunctionMap& function_map = GetBuiltinFunctionMap();//命令映射表
            return SubcontextMain(argc, argv, &function_map);
        if (!strcmp(argv[1], "selinux_setup")) {//selinux的初始化设置
            return SetupSelinux(argv);
        if (!strcmp(argv[1], "second_stage")) {
            return SecondStageMain(argc, argv); //init的第二阶段初始化
    return FirstStageMain(argc, argv); //init的第一阶段初始化
system/core/init/main.cpp

on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
    exec_start boringssl_self_test_apex32
on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
    exec_start boringssl_self_test_apex64
service boringssl_self_test32 /system/bin/boringssl_self_test32
    setenv BORINGSSL_SELF_TEST_CREATE_FLAG true # Any nonempty value counts as true
    reboot_on_failure reboot,boringssl-self-check-failed
    stdio_to_kmsg

static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
    Parser parser = CreateParser(action_manager, service_list);
    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.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");
        if (!parser.ParseConfig("/product/etc/init")) {
            late_import_paths.emplace_back("/product/etc/init");
        if (!parser.ParseConfig("/odm/etc/init")) {
            late_import_paths.emplace_back("/odm/etc/init");
        if (!parser.ParseConfig("/vendor/etc/init")) {
            late_import_paths.emplace_back("/vendor/etc/init");
    } else {
        parser.ParseConfig(bootscript);
}

struct parse_state
    char *ptr;      // 要解析的字符串
    char *text;     // 解析到的字符串，可以理解为返回一行的数据
    int line;       // 解析到第行数
    int nexttoken;  // 解析状态，有 T_EOF T_NEWLINE T_TEXT
};//其中 T_EOF 表示字符串解析结束，T_NEWLINE 表示解析完一行的数据，T_TEXT 表示解析到一个单词

void Parser::ParseData(const std::string& filename, std::string* data) {
    data->push_back('\n');  // TODO: fix tokenizer
    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 = [&] {//lambda类似于一个函数指针
        bad_section_found = false;
        if (section_parser == nullptr) return;
        //同样是调用相应的section的EndSection()结束该section的解析；
        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)) {
            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();
            */              //这部分是uevent的暂时跳过
            //section_parsers_ 是一个map，是在LoadBootScrip()第一行创建了三个键值对  "on"      ---> ActionParser
            //                                                                 "import"  ---> ImportParser
            //                                                                 "service" ---> ServiceParser
            //args[0]为某一行的第一个单词，该行由可能为section的开头，也有可能为command行，count()方法判断该行的第一个单词是不是为on/import/serivce，如果是则返回1
                } else if (section_parsers_.count(args[0])) { 
                    end_section();//在处理新的section前，结束之前的section；
                    section_parser = section_parsers_[args[0]].get(); //依据args[0]是on/import/service取出其对应的解析方法的地址ActionParser/ImportParser/ServiceParser
                    section_start_line = state.line;
                    if (auto result =
                                section_parser->ParseSection(std::move(args), filename, state.line); //调用相应的section解析函数(ActionParser/ImportParser/ServiceParser)解析section
                        !result.ok()) {
                        parse_error_count_++;
                        LOG(ERROR) << filename << ": " << state.line << ": " << result.error();
                        section_parser = nullptr;
                        bad_section_found = true;
                } else if (section_parser) {//该行的第一个单词不是新的section的开头，则使用上一次的解析方法的函数ActionParser/ImportParser/ServiceParser解析其命令行
                    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中
                args.emplace_back(state.text);
                break;
}

on boot
    ifup io
    start sshd

Result<void> ActionParser::ParseSection(std::vector<std::string>&& args,
                                        const std::string& filename, int line) {
    std::vector<std::string> triggers(args.begin() + 1, args.end());
    if (triggers.size() < 1) {
        return Error() << "Actions must have a trigger";
    Subcontext* action_subcontext = nullptr;
    if (subcontext_ && subcontext_->PathMatchesSubcontext(filename)) {
        action_subcontext = subcontext_;
    std::string event_trigger;
    std::map<std::string, std::string> property_triggers;
    if (auto result =
                ParseTriggers(triggers, action_subcontext, &event_trigger, &property_triggers);
        !result.ok()) {
        return Error() << "ParseTriggers() failed: " << result.error();
#ifdef G1122717
    for (const auto& [property, _] : property_triggers) {
        action_manager_->StartWatchingProperty(property);
#endif
    auto action = std::make_unique<Action>(false, action_subcontext, filename, line, event_trigger,
                                           property_triggers);
    action_ = std::move(action);
    return {};
}

Result<void> Action::AddCommand(std::vector<std::string>&& args, int line) {
    if (!function_map_) {
        return Error() << "no function map available";
    auto map_result = function_map_->Find(args);
    if (!map_result.ok()) {
        return Error() << map_result.error();
    commands_.emplace_back(map_result->function, map_result->run_in_subcontext, std::move(args),
                           line);
    return {};
}

Result<void> ActionParser::EndSection() {
    if (action_ && action_->NumCommands() > 0) {
        action_manager_->AddAction(std::move(action_));
    return {};
}

am.QueueBuiltinAction(SetupCgroupsAction, "SetupCgroups");
    am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");
    am.QueueBuiltinAction(TestPerfEventSelinuxAction, "TestPerfEventSelinux");
    am.QueueEventTrigger("early-init");
    // Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
    am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
    // ... so that we can start queuing up actions that require stuff from /dev.
    am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");
    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");
    // Trigger all the boot actions to get us started.
    am.QueueEventTrigger("init");

while (true) {
        // By default, sleep until something happens.
        // 决定timeout的时间
        auto epoll_timeout = std::optional<std::chrono::milliseconds>{};
        auto shutdown_command = shutdown_state.CheckShutdown();
        // 判断是否执行了关机
        if (shutdown_command) {
            HandlePowerctlMessage(*shutdown_command);
        //判断是否有事件需要处理
        if (!(prop_waiter_state.MightBeWaiting() || Service::is_exec_service_running())) {
            am.ExecuteOneCommand();
        if (!IsShuttingDown()) {
            auto next_process_action_time = HandleProcessActions();
            // If there's a process that needs restarting, wake up in time for that.
            if (next_process_action_time) {
                epoll_timeout = std::chrono::ceil<std::chrono::milliseconds>(
                        *next_process_action_time - boot_clock::now());
                if (*epoll_timeout < 0ms) epoll_timeout = 0ms;
        if (!(prop_waiter_state.MightBeWaiting() || Service::is_exec_service_running())) {
            // If there's more work to do, wake up again immediately.
            if (am.HasMoreCommands()) epoll_timeout = 0ms;
        auto pending_functions = epoll.Wait(epoll_timeout);
        if (!pending_functions.ok()) {
            LOG(ERROR) << pending_functions.error();
        } else if (!pending_functions->empty()) {
            // We always reap children before responding to the other pending functions. This is to
            // prevent a race where other daemons see that a service has exited and ask init to
            // start it again via ctl.start before init has reaped it.
            ReapAnyOutstandingChildren();
            for (const auto& function : *pending_functions) {
                (*function)();
        if (!IsShuttingDown()) {
            HandleControlMessages();
            SetUsbController();
    return 0;
}

void ActionManager::ExecuteOneCommand() {
        auto lock = std::lock_guard{event_queue_lock_};
        // 编译event_queue_ 队列直到有事件处理
        while (current_executing_actions_.empty() && !event_queue_.empty()) {
            //遍历action的向量（链表），包括所有解析出来的action，每一个action都包含了完整的信息（command，triggle等）
            for (const auto& action : actions_) {
            // 一个action是否要执行，事件trigger和属性trigger都必须要满足，这里检查event_queue_的第一个元素的属性事件是不是满足，会从属性map表里查找其值，如果满足才会执行下一步
                if (std::visit([&action](const auto& event) { return action->CheckEvent(event); },
                               event_queue_.front())) {
                    //如果满足这证明该action需要执行，把action压入current_executing_actions_当前执行队列中；
                    current_executing_actions_.emplace(action.get());
            event_queue_.pop();
    if (current_executing_actions_.empty()) {
        return;
    // 从当前需要执行的action队列中取出第一个要执行的action
    auto action = current_executing_actions_.front();
    if (current_command_ == 0) {
        std::string trigger_name = action->BuildTriggersString();
        LOG(INFO) << "processing action (" << trigger_name << ") from (" << action->filename()
                  << ":" << action->line() << ")";
    // 开始执行action
    action->ExecuteOneCommand(current_command_);
    // 如果这是当前需要执行的action的最后一个命令，则从current_executing_actions_队列中移除该action
    // 如果这个action只执行依次，则从actions_向量中移除它
    ++current_command_;
    if (current_command_ == action->NumCommands()) {
        current_executing_actions_.pop();
        current_command_ = 0;
        if (action->oneshot()) {
            auto eraser = [&action](std::unique_ptr<Action>& a) { return a.get() == action; };
            actions_.erase(std::remove_if(actions_.begin(), actions_.end(), eraser),
                           actions_.end());
}

Result<void> Command::InvokeFunc(Subcontext* subcontext) const {
    if (subcontext) {
        if (execute_in_subcontext_) {
            return subcontext->Execute(args_);
        auto expanded_args = subcontext->ExpandArgs(args_);
        if (!expanded_args.ok()) {
            return expanded_args.error();
        return RunBuiltinFunction(func_, *expanded_args, subcontext->context());
    return RunBuiltinFunction(func_, args_, kInitContext);
}