1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "init.h"
18
19#include <dirent.h>
20#include <fcntl.h>
21#include <paths.h>
22#include <pthread.h>
23#include <seccomp_policy.h>
24#include <signal.h>
25#include <stdlib.h>
26#include <string.h>
27#include <sys/epoll.h>
28#include <sys/mount.h>
29#include <sys/signalfd.h>
30#include <sys/sysmacros.h>
31#include <sys/types.h>
32#include <unistd.h>
33
34#include <android-base/chrono_utils.h>
35#include <android-base/file.h>
36#include <android-base/logging.h>
37#include <android-base/properties.h>
38#include <android-base/stringprintf.h>
39#include <android-base/strings.h>
40#include <cutils/android_reboot.h>
41#include <keyutils.h>
42#include <libavb/libavb.h>
43#include <private/android_filesystem_config.h>
44#include <selinux/android.h>
45
46#include <memory>
47#include <optional>
48
49#include "action_parser.h"
50#include "import_parser.h"
51#include "init_first_stage.h"
52#include "keychords.h"
53#include "log.h"
54#include "property_service.h"
55#include "reboot.h"
56#include "security.h"
57#include "selinux.h"
58#include "sigchld_handler.h"
59#include "ueventd.h"
60#include "util.h"
61#include "watchdogd.h"
62
63using namespace std::string_literals;
64
65using android::base::boot_clock;
66using android::base::GetProperty;
67using android::base::ReadFileToString;
68using android::base::StringPrintf;
69using android::base::Timer;
70using android::base::Trim;
71
72namespace android {
73namespace init {
74
75static int property_triggers_enabled = 0;
76
77static char qemu[32];
78
79std::string default_console = "/dev/console";
80
81static int epoll_fd = -1;
82static int sigterm_signal_fd = -1;
83
84static std::unique_ptr<Timer> waiting_for_prop(nullptr);
85static std::string wait_prop_name;
86static std::string wait_prop_value;
87static bool shutting_down;
88static std::string shutdown_command;
89static bool do_shutdown = false;
90
91std::vector<std::string> late_import_paths;
92
93static std::vector<Subcontext>* subcontexts;
94
95void DumpState() {
96    ServiceList::GetInstance().DumpState();
97    ActionManager::GetInstance().DumpState();
98}
99
100Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {
101    Parser parser;
102
103    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, subcontexts));
104    parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, subcontexts));
105    parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
106
107    return parser;
108}
109
110static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
111    Parser parser = CreateParser(action_manager, service_list);
112
113    std::string bootscript = GetProperty("ro.boot.init_rc", "");
114    if (bootscript.empty()) {
115        parser.ParseConfig("/init.rc");
116        if (!parser.ParseConfig("/system/etc/init")) {
117            late_import_paths.emplace_back("/system/etc/init");
118        }
119        if (!parser.ParseConfig("/product/etc/init")) {
120            late_import_paths.emplace_back("/product/etc/init");
121        }
122        if (!parser.ParseConfig("/odm/etc/init")) {
123            late_import_paths.emplace_back("/odm/etc/init");
124        }
125        if (!parser.ParseConfig("/vendor/etc/init")) {
126            late_import_paths.emplace_back("/vendor/etc/init");
127        }
128    } else {
129        parser.ParseConfig(bootscript);
130    }
131}
132
133void register_epoll_handler(int fd, void (*fn)()) {
134    epoll_event ev;
135    ev.events = EPOLLIN;
136    ev.data.ptr = reinterpret_cast<void*>(fn);
137    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
138        PLOG(ERROR) << "epoll_ctl failed";
139    }
140}
141
142bool start_waiting_for_property(const char *name, const char *value)
143{
144    if (waiting_for_prop) {
145        return false;
146    }
147    if (GetProperty(name, "") != value) {
148        // Current property value is not equal to expected value
149        wait_prop_name = name;
150        wait_prop_value = value;
151        waiting_for_prop.reset(new Timer());
152    } else {
153        LOG(INFO) << "start_waiting_for_property(\""
154                  << name << "\", \"" << value << "\"): already set";
155    }
156    return true;
157}
158
159void ResetWaitForProp() {
160    wait_prop_name.clear();
161    wait_prop_value.clear();
162    waiting_for_prop.reset();
163}
164
165void property_changed(const std::string& name, const std::string& value) {
166    // If the property is sys.powerctl, we bypass the event queue and immediately handle it.
167    // This is to ensure that init will always and immediately shutdown/reboot, regardless of
168    // if there are other pending events to process or if init is waiting on an exec service or
169    // waiting on a property.
170    // In non-thermal-shutdown case, 'shutdown' trigger will be fired to let device specific
171    // commands to be executed.
172    if (name == "sys.powerctl") {
173        // Despite the above comment, we can't call HandlePowerctlMessage() in this function,
174        // because it modifies the contents of the action queue, which can cause the action queue
175        // to get into a bad state if this function is called from a command being executed by the
176        // action queue.  Instead we set this flag and ensure that shutdown happens before the next
177        // command is run in the main init loop.
178        // TODO: once property service is removed from init, this will never happen from a builtin,
179        // but rather from a callback from the property service socket, in which case this hack can
180        // go away.
181        shutdown_command = value;
182        do_shutdown = true;
183    }
184
185    if (property_triggers_enabled) ActionManager::GetInstance().QueuePropertyChange(name, value);
186
187    if (waiting_for_prop) {
188        if (wait_prop_name == name && wait_prop_value == value) {
189            LOG(INFO) << "Wait for property took " << *waiting_for_prop;
190            ResetWaitForProp();
191        }
192    }
193}
194
195static std::optional<boot_clock::time_point> RestartProcesses() {
196    std::optional<boot_clock::time_point> next_process_restart_time;
197    for (const auto& s : ServiceList::GetInstance()) {
198        if (!(s->flags() & SVC_RESTARTING)) continue;
199
200        auto restart_time = s->time_started() + 5s;
201        if (boot_clock::now() > restart_time) {
202            if (auto result = s->Start(); !result) {
203                LOG(ERROR) << "Could not restart process '" << s->name() << "': " << result.error();
204            }
205        } else {
206            if (!next_process_restart_time || restart_time < *next_process_restart_time) {
207                next_process_restart_time = restart_time;
208            }
209        }
210    }
211    return next_process_restart_time;
212}
213
214static Result<Success> DoControlStart(Service* service) {
215    return service->Start();
216}
217
218static Result<Success> DoControlStop(Service* service) {
219    service->Stop();
220    return Success();
221}
222
223static Result<Success> DoControlRestart(Service* service) {
224    service->Restart();
225    return Success();
226}
227
228enum class ControlTarget {
229    SERVICE,    // function gets called for the named service
230    INTERFACE,  // action gets called for every service that holds this interface
231};
232
233struct ControlMessageFunction {
234    ControlTarget target;
235    std::function<Result<Success>(Service*)> action;
236};
237
238static const std::map<std::string, ControlMessageFunction>& get_control_message_map() {
239    // clang-format off
240    static const std::map<std::string, ControlMessageFunction> control_message_functions = {
241        {"start",             {ControlTarget::SERVICE,   DoControlStart}},
242        {"stop",              {ControlTarget::SERVICE,   DoControlStop}},
243        {"restart",           {ControlTarget::SERVICE,   DoControlRestart}},
244        {"interface_start",   {ControlTarget::INTERFACE, DoControlStart}},
245        {"interface_stop",    {ControlTarget::INTERFACE, DoControlStop}},
246        {"interface_restart", {ControlTarget::INTERFACE, DoControlRestart}},
247    };
248    // clang-format on
249
250    return control_message_functions;
251}
252
253void HandleControlMessage(const std::string& msg, const std::string& name, pid_t pid) {
254    const auto& map = get_control_message_map();
255    const auto it = map.find(msg);
256
257    if (it == map.end()) {
258        LOG(ERROR) << "Unknown control msg '" << msg << "'";
259        return;
260    }
261
262    std::string cmdline_path = StringPrintf("proc/%d/cmdline", pid);
263    std::string process_cmdline;
264    if (ReadFileToString(cmdline_path, &process_cmdline)) {
265        std::replace(process_cmdline.begin(), process_cmdline.end(), '\0', ' ');
266        process_cmdline = Trim(process_cmdline);
267    } else {
268        process_cmdline = "unknown process";
269    }
270
271    LOG(INFO) << "Received control message '" << msg << "' for '" << name << "' from pid: " << pid
272              << " (" << process_cmdline << ")";
273
274    const ControlMessageFunction& function = it->second;
275
276    if (function.target == ControlTarget::SERVICE) {
277        Service* svc = ServiceList::GetInstance().FindService(name);
278        if (svc == nullptr) {
279            LOG(ERROR) << "No such service '" << name << "' for ctl." << msg;
280            return;
281        }
282        if (auto result = function.action(svc); !result) {
283            LOG(ERROR) << "Could not ctl." << msg << " for service " << name << ": "
284                       << result.error();
285        }
286
287        return;
288    }
289
290    if (function.target == ControlTarget::INTERFACE) {
291        for (const auto& svc : ServiceList::GetInstance()) {
292            if (svc->interfaces().count(name) == 0) {
293                continue;
294            }
295
296            if (auto result = function.action(svc.get()); !result) {
297                LOG(ERROR) << "Could not handle ctl." << msg << " for service " << svc->name()
298                           << " with interface " << name << ": " << result.error();
299            }
300
301            return;
302        }
303
304        LOG(ERROR) << "Could not find service hosting interface " << name;
305        return;
306    }
307
308    LOG(ERROR) << "Invalid function target from static map key '" << msg
309               << "': " << static_cast<std::underlying_type<ControlTarget>::type>(function.target);
310}
311
312static Result<Success> wait_for_coldboot_done_action(const BuiltinArguments& args) {
313    Timer t;
314
315    LOG(VERBOSE) << "Waiting for " COLDBOOT_DONE "...";
316
317    // Historically we had a 1s timeout here because we weren't otherwise
318    // tracking boot time, and many OEMs made their sepolicy regular
319    // expressions too expensive (http://b/19899875).
320
321    // Now we're tracking boot time, just log the time taken to a system
322    // property. We still panic if it takes more than a minute though,
323    // because any build that slow isn't likely to boot at all, and we'd
324    // rather any test lab devices fail back to the bootloader.
325    if (wait_for_file(COLDBOOT_DONE, 60s) < 0) {
326        LOG(FATAL) << "Timed out waiting for " COLDBOOT_DONE;
327    }
328
329    property_set("ro.boottime.init.cold_boot_wait", std::to_string(t.duration().count()));
330    return Success();
331}
332
333static Result<Success> keychord_init_action(const BuiltinArguments& args) {
334    keychord_init();
335    return Success();
336}
337
338static Result<Success> console_init_action(const BuiltinArguments& args) {
339    std::string console = GetProperty("ro.boot.console", "");
340    if (!console.empty()) {
341        default_console = "/dev/" + console;
342    }
343    return Success();
344}
345
346static void import_kernel_nv(const std::string& key, const std::string& value, bool for_emulator) {
347    if (key.empty()) return;
348
349    if (for_emulator) {
350        // In the emulator, export any kernel option with the "ro.kernel." prefix.
351        property_set("ro.kernel." + key, value);
352        return;
353    }
354
355    if (key == "qemu") {
356        strlcpy(qemu, value.c_str(), sizeof(qemu));
357    } else if (android::base::StartsWith(key, "androidboot.")) {
358        property_set("ro.boot." + key.substr(12), value);
359    }
360}
361
362static void export_oem_lock_status() {
363    if (!android::base::GetBoolProperty("ro.oem_unlock_supported", false)) {
364        return;
365    }
366
367    std::string value = GetProperty("ro.boot.verifiedbootstate", "");
368
369    if (!value.empty()) {
370        property_set("ro.boot.flash.locked", value == "orange" ? "0" : "1");
371    }
372}
373
374static void export_kernel_boot_props() {
375    struct {
376        const char *src_prop;
377        const char *dst_prop;
378        const char *default_value;
379    } prop_map[] = {
380        { "ro.boot.serialno",   "ro.serialno",   "", },
381        { "ro.boot.mode",       "ro.bootmode",   "unknown", },
382        { "ro.boot.baseband",   "ro.baseband",   "unknown", },
383        { "ro.boot.bootloader", "ro.bootloader", "unknown", },
384        { "ro.boot.hardware",   "ro.hardware",   "unknown", },
385        { "ro.boot.revision",   "ro.revision",   "0", },
386    };
387    for (size_t i = 0; i < arraysize(prop_map); i++) {
388        std::string value = GetProperty(prop_map[i].src_prop, "");
389        property_set(prop_map[i].dst_prop, (!value.empty()) ? value : prop_map[i].default_value);
390    }
391}
392
393static void process_kernel_dt() {
394    if (!is_android_dt_value_expected("compatible", "android,firmware")) {
395        return;
396    }
397
398    std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(get_android_dt_dir().c_str()), closedir);
399    if (!dir) return;
400
401    std::string dt_file;
402    struct dirent *dp;
403    while ((dp = readdir(dir.get())) != NULL) {
404        if (dp->d_type != DT_REG || !strcmp(dp->d_name, "compatible") || !strcmp(dp->d_name, "name")) {
405            continue;
406        }
407
408        std::string file_name = get_android_dt_dir() + dp->d_name;
409
410        android::base::ReadFileToString(file_name, &dt_file);
411        std::replace(dt_file.begin(), dt_file.end(), ',', '.');
412
413        property_set("ro.boot."s + dp->d_name, dt_file);
414    }
415}
416
417static void process_kernel_cmdline() {
418    // The first pass does the common stuff, and finds if we are in qemu.
419    // The second pass is only necessary for qemu to export all kernel params
420    // as properties.
421    import_kernel_cmdline(false, import_kernel_nv);
422    if (qemu[0]) import_kernel_cmdline(true, import_kernel_nv);
423}
424
425static Result<Success> property_enable_triggers_action(const BuiltinArguments& args) {
426    /* Enable property triggers. */
427    property_triggers_enabled = 1;
428    return Success();
429}
430
431static Result<Success> queue_property_triggers_action(const BuiltinArguments& args) {
432    ActionManager::GetInstance().QueueBuiltinAction(property_enable_triggers_action, "enable_property_trigger");
433    ActionManager::GetInstance().QueueAllPropertyActions();
434    return Success();
435}
436
437static void global_seccomp() {
438    import_kernel_cmdline(false, [](const std::string& key, const std::string& value, bool in_qemu) {
439        if (key == "androidboot.seccomp" && value == "global" && !set_global_seccomp_filter()) {
440            LOG(FATAL) << "Failed to globally enable seccomp!";
441        }
442    });
443}
444
445// Set the UDC controller for the ConfigFS USB Gadgets.
446// Read the UDC controller in use from "/sys/class/udc".
447// In case of multiple UDC controllers select the first one.
448static void set_usb_controller() {
449    std::unique_ptr<DIR, decltype(&closedir)>dir(opendir("/sys/class/udc"), closedir);
450    if (!dir) return;
451
452    dirent* dp;
453    while ((dp = readdir(dir.get())) != nullptr) {
454        if (dp->d_name[0] == '.') continue;
455
456        property_set("sys.usb.controller", dp->d_name);
457        break;
458    }
459}
460
461static void InstallRebootSignalHandlers() {
462    // Instead of panic'ing the kernel as is the default behavior when init crashes,
463    // we prefer to reboot to bootloader on development builds, as this will prevent
464    // boot looping bad configurations and allow both developers and test farms to easily
465    // recover.
466    struct sigaction action;
467    memset(&action, 0, sizeof(action));
468    sigfillset(&action.sa_mask);
469    action.sa_handler = [](int signal) {
470        // These signal handlers are also caught for processes forked from init, however we do not
471        // want them to trigger reboot, so we directly call _exit() for children processes here.
472        if (getpid() != 1) {
473            _exit(signal);
474        }
475
476        // Calling DoReboot() or LOG(FATAL) is not a good option as this is a signal handler.
477        // RebootSystem uses syscall() which isn't actually async-signal-safe, but our only option
478        // and probably good enough given this is already an error case and only enabled for
479        // development builds.
480        RebootSystem(ANDROID_RB_RESTART2, "bootloader");
481    };
482    action.sa_flags = SA_RESTART;
483    sigaction(SIGABRT, &action, nullptr);
484    sigaction(SIGBUS, &action, nullptr);
485    sigaction(SIGFPE, &action, nullptr);
486    sigaction(SIGILL, &action, nullptr);
487    sigaction(SIGSEGV, &action, nullptr);
488#if defined(SIGSTKFLT)
489    sigaction(SIGSTKFLT, &action, nullptr);
490#endif
491    sigaction(SIGSYS, &action, nullptr);
492    sigaction(SIGTRAP, &action, nullptr);
493}
494
495static void HandleSigtermSignal() {
496    signalfd_siginfo siginfo;
497    ssize_t bytes_read = TEMP_FAILURE_RETRY(read(sigterm_signal_fd, &siginfo, sizeof(siginfo)));
498    if (bytes_read != sizeof(siginfo)) {
499        PLOG(ERROR) << "Failed to read siginfo from sigterm_signal_fd";
500        return;
501    }
502
503    if (siginfo.ssi_pid != 0) {
504        // Drop any userspace SIGTERM requests.
505        LOG(DEBUG) << "Ignoring SIGTERM from pid " << siginfo.ssi_pid;
506        return;
507    }
508
509    HandlePowerctlMessage("shutdown,container");
510}
511
512static void UnblockSigterm() {
513    sigset_t mask;
514    sigemptyset(&mask);
515    sigaddset(&mask, SIGTERM);
516
517    if (sigprocmask(SIG_UNBLOCK, &mask, nullptr) == -1) {
518        PLOG(FATAL) << "failed to unblock SIGTERM for PID " << getpid();
519    }
520}
521
522static void InstallSigtermHandler() {
523    sigset_t mask;
524    sigemptyset(&mask);
525    sigaddset(&mask, SIGTERM);
526
527    if (sigprocmask(SIG_BLOCK, &mask, nullptr) == -1) {
528        PLOG(FATAL) << "failed to block SIGTERM";
529    }
530
531    // Register a handler to unblock SIGTERM in the child processes.
532    const int result = pthread_atfork(nullptr, nullptr, &UnblockSigterm);
533    if (result != 0) {
534        LOG(FATAL) << "Failed to register a fork handler: " << strerror(result);
535    }
536
537    sigterm_signal_fd = signalfd(-1, &mask, SFD_CLOEXEC);
538    if (sigterm_signal_fd == -1) {
539        PLOG(FATAL) << "failed to create signalfd for SIGTERM";
540    }
541
542    register_epoll_handler(sigterm_signal_fd, HandleSigtermSignal);
543}
544
545int main(int argc, char** argv) {
546    if (!strcmp(basename(argv[0]), "ueventd")) {
547        return ueventd_main(argc, argv);
548    }
549
550    if (!strcmp(basename(argv[0]), "watchdogd")) {
551        return watchdogd_main(argc, argv);
552    }
553
554    if (argc > 1 && !strcmp(argv[1], "subcontext")) {
555        InitKernelLogging(argv);
556        const BuiltinFunctionMap function_map;
557        return SubcontextMain(argc, argv, &function_map);
558    }
559
560    if (REBOOT_BOOTLOADER_ON_PANIC) {
561        InstallRebootSignalHandlers();
562    }
563
564    bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);
565
566    if (is_first_stage) {
567        boot_clock::time_point start_time = boot_clock::now();
568
569        // Clear the umask.
570        umask(0);
571
572        clearenv();
573        setenv("PATH", _PATH_DEFPATH, 1);
574        // Get the basic filesystem setup we need put together in the initramdisk
575        // on / and then we'll let the rc file figure out the rest.
576        mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
577        mkdir("/dev/pts", 0755);
578        mkdir("/dev/socket", 0755);
579        mount("devpts", "/dev/pts", "devpts", 0, NULL);
580        #define MAKE_STR(x) __STRING(x)
581        mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
582        // Don't expose the raw commandline to unprivileged processes.
583        chmod("/proc/cmdline", 0440);
584        gid_t groups[] = { AID_READPROC };
585        setgroups(arraysize(groups), groups);
586        mount("sysfs", "/sys", "sysfs", 0, NULL);
587        mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
588
589        mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
590
591        if constexpr (WORLD_WRITABLE_KMSG) {
592            mknod("/dev/kmsg_debug", S_IFCHR | 0622, makedev(1, 11));
593        }
594
595        mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
596        mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
597
598        // Mount staging areas for devices managed by vold
599        // See storage config details at http://source.android.com/devices/storage/
600        mount("tmpfs", "/mnt", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV,
601              "mode=0755,uid=0,gid=1000");
602        // /mnt/vendor is used to mount vendor-specific partitions that can not be
603        // part of the vendor partition, e.g. because they are mounted read-write.
604        mkdir("/mnt/vendor", 0755);
605
606        // Now that tmpfs is mounted on /dev and we have /dev/kmsg, we can actually
607        // talk to the outside world...
608        InitKernelLogging(argv);
609
610        LOG(INFO) << "init first stage started!";
611
612        if (!DoFirstStageMount()) {
613            LOG(FATAL) << "Failed to mount required partitions early ...";
614        }
615
616        SetInitAvbVersionInRecovery();
617
618        // Enable seccomp if global boot option was passed (otherwise it is enabled in zygote).
619        global_seccomp();
620
621        // Set up SELinux, loading the SELinux policy.
622        SelinuxSetupKernelLogging();
623        SelinuxInitialize();
624
625        // We're in the kernel domain, so re-exec init to transition to the init domain now
626        // that the SELinux policy has been loaded.
627        if (selinux_android_restorecon("/init", 0) == -1) {
628            PLOG(FATAL) << "restorecon failed of /init failed";
629        }
630
631        setenv("INIT_SECOND_STAGE", "true", 1);
632
633        static constexpr uint32_t kNanosecondsPerMillisecond = 1e6;
634        uint64_t start_ms = start_time.time_since_epoch().count() / kNanosecondsPerMillisecond;
635        setenv("INIT_STARTED_AT", std::to_string(start_ms).c_str(), 1);
636
637        char* path = argv[0];
638        char* args[] = { path, nullptr };
639        execv(path, args);
640
641        // execv() only returns if an error happened, in which case we
642        // panic and never fall through this conditional.
643        PLOG(FATAL) << "execv(\"" << path << "\") failed";
644    }
645
646    // At this point we're in the second stage of init.
647    InitKernelLogging(argv);
648    LOG(INFO) << "init second stage started!";
649
650    // Set up a session keyring that all processes will have access to. It
651    // will hold things like FBE encryption keys. No process should override
652    // its session keyring.
653    keyctl_get_keyring_ID(KEY_SPEC_SESSION_KEYRING, 1);
654
655    // Indicate that booting is in progress to background fw loaders, etc.
656    close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
657
658    property_init();
659
660    // If arguments are passed both on the command line and in DT,
661    // properties set in DT always have priority over the command-line ones.
662    process_kernel_dt();
663    process_kernel_cmdline();
664
665    // Propagate the kernel variables to internal variables
666    // used by init as well as the current required properties.
667    export_kernel_boot_props();
668
669    // Make the time that init started available for bootstat to log.
670    property_set("ro.boottime.init", getenv("INIT_STARTED_AT"));
671    property_set("ro.boottime.init.selinux", getenv("INIT_SELINUX_TOOK"));
672
673    // Set libavb version for Framework-only OTA match in Treble build.
674    const char* avb_version = getenv("INIT_AVB_VERSION");
675    if (avb_version) property_set("ro.boot.avb_version", avb_version);
676
677    // Clean up our environment.
678    unsetenv("INIT_SECOND_STAGE");
679    unsetenv("INIT_STARTED_AT");
680    unsetenv("INIT_SELINUX_TOOK");
681    unsetenv("INIT_AVB_VERSION");
682
683    // Now set up SELinux for second stage.
684    SelinuxSetupKernelLogging();
685    SelabelInitialize();
686    SelinuxRestoreContext();
687
688    epoll_fd = epoll_create1(EPOLL_CLOEXEC);
689    if (epoll_fd == -1) {
690        PLOG(FATAL) << "epoll_create1 failed";
691    }
692
693    sigchld_handler_init();
694
695    if (!IsRebootCapable()) {
696        // If init does not have the CAP_SYS_BOOT capability, it is running in a container.
697        // In that case, receiving SIGTERM will cause the system to shut down.
698        InstallSigtermHandler();
699    }
700
701    property_load_boot_defaults();
702    export_oem_lock_status();
703    start_property_service();
704    set_usb_controller();
705
706    const BuiltinFunctionMap function_map;
707    Action::set_function_map(&function_map);
708
709    subcontexts = InitializeSubcontexts();
710
711    ActionManager& am = ActionManager::GetInstance();
712    ServiceList& sm = ServiceList::GetInstance();
713
714    LoadBootScripts(am, sm);
715
716    // Turning this on and letting the INFO logging be discarded adds 0.2s to
717    // Nexus 9 boot time, so it's disabled by default.
718    if (false) DumpState();
719
720    am.QueueEventTrigger("early-init");
721
722    // Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
723    am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
724    // ... so that we can start queuing up actions that require stuff from /dev.
725    am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");
726    am.QueueBuiltinAction(SetMmapRndBitsAction, "SetMmapRndBits");
727    am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");
728    am.QueueBuiltinAction(keychord_init_action, "keychord_init");
729    am.QueueBuiltinAction(console_init_action, "console_init");
730
731    // Trigger all the boot actions to get us started.
732    am.QueueEventTrigger("init");
733
734    // Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
735    // wasn't ready immediately after wait_for_coldboot_done
736    am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");
737
738    // Don't mount filesystems or start core system services in charger mode.
739    std::string bootmode = GetProperty("ro.bootmode", "");
740    if (bootmode == "charger") {
741        am.QueueEventTrigger("charger");
742    } else {
743        am.QueueEventTrigger("late-init");
744    }
745
746    // Run all property triggers based on current state of the properties.
747    am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
748
749    while (true) {
750        // By default, sleep until something happens.
751        int epoll_timeout_ms = -1;
752
753        if (do_shutdown && !shutting_down) {
754            do_shutdown = false;
755            if (HandlePowerctlMessage(shutdown_command)) {
756                shutting_down = true;
757            }
758        }
759
760        if (!(waiting_for_prop || Service::is_exec_service_running())) {
761            am.ExecuteOneCommand();
762        }
763        if (!(waiting_for_prop || Service::is_exec_service_running())) {
764            if (!shutting_down) {
765                auto next_process_restart_time = RestartProcesses();
766
767                // If there's a process that needs restarting, wake up in time for that.
768                if (next_process_restart_time) {
769                    epoll_timeout_ms = std::chrono::ceil<std::chrono::milliseconds>(
770                                           *next_process_restart_time - boot_clock::now())
771                                           .count();
772                    if (epoll_timeout_ms < 0) epoll_timeout_ms = 0;
773                }
774            }
775
776            // If there's more work to do, wake up again immediately.
777            if (am.HasMoreCommands()) epoll_timeout_ms = 0;
778        }
779
780        epoll_event ev;
781        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, epoll_timeout_ms));
782        if (nr == -1) {
783            PLOG(ERROR) << "epoll_wait failed";
784        } else if (nr == 1) {
785            ((void (*)()) ev.data.ptr)();
786        }
787    }
788
789    return 0;
790}
791
792}  // namespace init
793}  // namespace android
794