| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "init.h" |
| |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <paths.h> |
| #include <pthread.h> |
| #include <seccomp_policy.h> |
| #include <signal.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/mount.h> |
| #include <sys/signalfd.h> |
| #include <sys/sysmacros.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <map> |
| #include <memory> |
| #include <optional> |
| |
| #include <android-base/chrono_utils.h> |
| #include <android-base/file.h> |
| #include <android-base/logging.h> |
| #include <android-base/properties.h> |
| #include <android-base/stringprintf.h> |
| #include <android-base/strings.h> |
| #include <cutils/android_reboot.h> |
| #include <keyutils.h> |
| #include <libavb/libavb.h> |
| #include <private/android_filesystem_config.h> |
| #include <selinux/android.h> |
| |
| #include "action_parser.h" |
| #include "epoll.h" |
| #include "import_parser.h" |
| #include "init_first_stage.h" |
| #include "keychords.h" |
| #include "log.h" |
| #include "property_service.h" |
| #include "reboot.h" |
| #include "security.h" |
| #include "selinux.h" |
| #include "sigchld_handler.h" |
| #include "ueventd.h" |
| #include "util.h" |
| #include "watchdogd.h" |
| |
| using namespace std::chrono_literals; |
| using namespace std::string_literals; |
| |
| using android::base::boot_clock; |
| using android::base::GetProperty; |
| using android::base::ReadFileToString; |
| using android::base::StringPrintf; |
| using android::base::Timer; |
| using android::base::Trim; |
| |
| namespace android { |
| namespace init { |
| |
| static int property_triggers_enabled = 0; |
| |
| static char qemu[32]; |
| |
| std::string default_console = "/dev/console"; |
| |
| static int signal_fd = -1; |
| |
| static std::unique_ptr<Timer> waiting_for_prop(nullptr); |
| static std::string wait_prop_name; |
| static std::string wait_prop_value; |
| static bool shutting_down; |
| static std::string shutdown_command; |
| static bool do_shutdown = false; |
| |
| std::vector<std::string> late_import_paths; |
| |
| static std::vector<Subcontext>* subcontexts; |
| |
| void DumpState() { |
| ServiceList::GetInstance().DumpState(); |
| ActionManager::GetInstance().DumpState(); |
| } |
| |
| Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) { |
| Parser parser; |
| |
| parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, subcontexts)); |
| parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, subcontexts)); |
| parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser)); |
| |
| return parser; |
| } |
| |
| 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("/init.rc"); |
| if (!parser.ParseConfig("/system/etc/init")) { |
| late_import_paths.emplace_back("/system/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); |
| } |
| } |
| |
| bool start_waiting_for_property(const char *name, const char *value) |
| { |
| if (waiting_for_prop) { |
| return false; |
| } |
| if (GetProperty(name, "") != value) { |
| // Current property value is not equal to expected value |
| wait_prop_name = name; |
| wait_prop_value = value; |
| waiting_for_prop.reset(new Timer()); |
| } else { |
| LOG(INFO) << "start_waiting_for_property(\"" |
| << name << "\", \"" << value << "\"): already set"; |
| } |
| return true; |
| } |
| |
| void ResetWaitForProp() { |
| wait_prop_name.clear(); |
| wait_prop_value.clear(); |
| waiting_for_prop.reset(); |
| } |
| |
| void property_changed(const std::string& name, const std::string& value) { |
| // If the property is sys.powerctl, we bypass the event queue and immediately handle it. |
| // This is to ensure that init will always and immediately shutdown/reboot, regardless of |
| // if there are other pending events to process or if init is waiting on an exec service or |
| // waiting on a property. |
| // In non-thermal-shutdown case, 'shutdown' trigger will be fired to let device specific |
| // commands to be executed. |
| if (name == "sys.powerctl") { |
| // Despite the above comment, we can't call HandlePowerctlMessage() in this function, |
| // because it modifies the contents of the action queue, which can cause the action queue |
| // to get into a bad state if this function is called from a command being executed by the |
| // action queue. Instead we set this flag and ensure that shutdown happens before the next |
| // command is run in the main init loop. |
| // TODO: once property service is removed from init, this will never happen from a builtin, |
| // but rather from a callback from the property service socket, in which case this hack can |
| // go away. |
| shutdown_command = value; |
| do_shutdown = true; |
| } |
| |
| if (property_triggers_enabled) ActionManager::GetInstance().QueuePropertyChange(name, value); |
| |
| if (waiting_for_prop) { |
| if (wait_prop_name == name && wait_prop_value == value) { |
| LOG(INFO) << "Wait for property took " << *waiting_for_prop; |
| ResetWaitForProp(); |
| } |
| } |
| } |
| |
| static std::optional<boot_clock::time_point> RestartProcesses() { |
| std::optional<boot_clock::time_point> next_process_restart_time; |
| for (const auto& s : ServiceList::GetInstance()) { |
| if (!(s->flags() & SVC_RESTARTING)) continue; |
| |
| auto restart_time = s->time_started() + 5s; |
| if (boot_clock::now() > restart_time) { |
| if (auto result = s->Start(); !result) { |
| LOG(ERROR) << "Could not restart process '" << s->name() << "': " << result.error(); |
| } |
| } else { |
| if (!next_process_restart_time || restart_time < *next_process_restart_time) { |
| next_process_restart_time = restart_time; |
| } |
| } |
| } |
| return next_process_restart_time; |
| } |
| |
| static Result<Success> DoControlStart(Service* service) { |
| return service->Start(); |
| } |
| |
| static Result<Success> DoControlStop(Service* service) { |
| service->Stop(); |
| return Success(); |
| } |
| |
| static Result<Success> DoControlRestart(Service* service) { |
| service->Restart(); |
| return Success(); |
| } |
| |
| enum class ControlTarget { |
| SERVICE, // function gets called for the named service |
| INTERFACE, // action gets called for every service that holds this interface |
| }; |
| |
| struct ControlMessageFunction { |
| ControlTarget target; |
| std::function<Result<Success>(Service*)> action; |
| }; |
| |
| static const std::map<std::string, ControlMessageFunction>& get_control_message_map() { |
| // clang-format off |
| static const std::map<std::string, ControlMessageFunction> control_message_functions = { |
| {"sigstop_on", {ControlTarget::SERVICE, |
| [](auto* service) { service->set_sigstop(true); return Success(); }}}, |
| {"sigstop_off", {ControlTarget::SERVICE, |
| [](auto* service) { service->set_sigstop(false); return Success(); }}}, |
| {"start", {ControlTarget::SERVICE, DoControlStart}}, |
| {"stop", {ControlTarget::SERVICE, DoControlStop}}, |
| {"restart", {ControlTarget::SERVICE, DoControlRestart}}, |
| {"interface_start", {ControlTarget::INTERFACE, DoControlStart}}, |
| {"interface_stop", {ControlTarget::INTERFACE, DoControlStop}}, |
| {"interface_restart", {ControlTarget::INTERFACE, DoControlRestart}}, |
| }; |
| // clang-format on |
| |
| return control_message_functions; |
| } |
| |
| void HandleControlMessage(const std::string& msg, const std::string& name, pid_t pid) { |
| const auto& map = get_control_message_map(); |
| const auto it = map.find(msg); |
| |
| if (it == map.end()) { |
| LOG(ERROR) << "Unknown control msg '" << msg << "'"; |
| return; |
| } |
| |
| std::string cmdline_path = StringPrintf("proc/%d/cmdline", pid); |
| std::string process_cmdline; |
| if (ReadFileToString(cmdline_path, &process_cmdline)) { |
| std::replace(process_cmdline.begin(), process_cmdline.end(), '\0', ' '); |
| process_cmdline = Trim(process_cmdline); |
| } else { |
| process_cmdline = "unknown process"; |
| } |
| |
| LOG(INFO) << "Received control message '" << msg << "' for '" << name << "' from pid: " << pid |
| << " (" << process_cmdline << ")"; |
| |
| const ControlMessageFunction& function = it->second; |
| |
| Service* svc = nullptr; |
| |
| switch (function.target) { |
| case ControlTarget::SERVICE: |
| svc = ServiceList::GetInstance().FindService(name); |
| break; |
| case ControlTarget::INTERFACE: |
| svc = ServiceList::GetInstance().FindInterface(name); |
| break; |
| default: |
| LOG(ERROR) << "Invalid function target from static map key '" << msg << "': " |
| << static_cast<std::underlying_type<ControlTarget>::type>(function.target); |
| return; |
| } |
| |
| if (svc == nullptr) { |
| LOG(ERROR) << "Could not find '" << name << "' for ctl." << msg; |
| return; |
| } |
| |
| if (auto result = function.action(svc); !result) { |
| LOG(ERROR) << "Could not ctl." << msg << " for '" << name << "': " << result.error(); |
| } |
| } |
| |
| static Result<Success> wait_for_coldboot_done_action(const BuiltinArguments& args) { |
| Timer t; |
| |
| LOG(VERBOSE) << "Waiting for " COLDBOOT_DONE "..."; |
| |
| // Historically we had a 1s timeout here because we weren't otherwise |
| // tracking boot time, and many OEMs made their sepolicy regular |
| // expressions too expensive (http://b/19899875). |
| |
| // Now we're tracking boot time, just log the time taken to a system |
| // property. We still panic if it takes more than a minute though, |
| // because any build that slow isn't likely to boot at all, and we'd |
| // rather any test lab devices fail back to the bootloader. |
| if (wait_for_file(COLDBOOT_DONE, 60s) < 0) { |
| LOG(FATAL) << "Timed out waiting for " COLDBOOT_DONE; |
| } |
| |
| property_set("ro.boottime.init.cold_boot_wait", std::to_string(t.duration().count())); |
| return Success(); |
| } |
| |
| static Result<Success> console_init_action(const BuiltinArguments& args) { |
| std::string console = GetProperty("ro.boot.console", ""); |
| if (!console.empty()) { |
| default_console = "/dev/" + console; |
| } |
| return Success(); |
| } |
| |
| static void import_kernel_nv(const std::string& key, const std::string& value, bool for_emulator) { |
| if (key.empty()) return; |
| |
| if (for_emulator) { |
| // In the emulator, export any kernel option with the "ro.kernel." prefix. |
| property_set("ro.kernel." + key, value); |
| return; |
| } |
| |
| if (key == "qemu") { |
| strlcpy(qemu, value.c_str(), sizeof(qemu)); |
| } else if (android::base::StartsWith(key, "androidboot.")) { |
| property_set("ro.boot." + key.substr(12), value); |
| } |
| } |
| |
| static void export_oem_lock_status() { |
| if (!android::base::GetBoolProperty("ro.oem_unlock_supported", false)) { |
| return; |
| } |
| |
| std::string value = GetProperty("ro.boot.verifiedbootstate", ""); |
| |
| if (!value.empty()) { |
| property_set("ro.boot.flash.locked", value == "orange" ? "0" : "1"); |
| } |
| } |
| |
| static void export_kernel_boot_props() { |
| constexpr const char* UNSET = ""; |
| struct { |
| const char *src_prop; |
| const char *dst_prop; |
| const char *default_value; |
| } prop_map[] = { |
| { "ro.boot.serialno", "ro.serialno", UNSET, }, |
| { "ro.boot.mode", "ro.bootmode", "unknown", }, |
| { "ro.boot.baseband", "ro.baseband", "unknown", }, |
| { "ro.boot.bootloader", "ro.bootloader", "unknown", }, |
| { "ro.boot.hardware", "ro.hardware", "unknown", }, |
| { "ro.boot.revision", "ro.revision", "0", }, |
| }; |
| for (const auto& prop : prop_map) { |
| std::string value = GetProperty(prop.src_prop, prop.default_value); |
| if (value != UNSET) |
| property_set(prop.dst_prop, value); |
| } |
| } |
| |
| static void process_kernel_dt() { |
| if (!is_android_dt_value_expected("compatible", "android,firmware")) { |
| return; |
| } |
| |
| std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(get_android_dt_dir().c_str()), closedir); |
| if (!dir) return; |
| |
| std::string dt_file; |
| struct dirent *dp; |
| while ((dp = readdir(dir.get())) != NULL) { |
| if (dp->d_type != DT_REG || !strcmp(dp->d_name, "compatible") || !strcmp(dp->d_name, "name")) { |
| continue; |
| } |
| |
| std::string file_name = get_android_dt_dir() + dp->d_name; |
| |
| android::base::ReadFileToString(file_name, &dt_file); |
| std::replace(dt_file.begin(), dt_file.end(), ',', '.'); |
| |
| property_set("ro.boot."s + dp->d_name, dt_file); |
| } |
| } |
| |
| static void process_kernel_cmdline() { |
| // The first pass does the common stuff, and finds if we are in qemu. |
| // The second pass is only necessary for qemu to export all kernel params |
| // as properties. |
| import_kernel_cmdline(false, import_kernel_nv); |
| if (qemu[0]) import_kernel_cmdline(true, import_kernel_nv); |
| } |
| |
| static Result<Success> property_enable_triggers_action(const BuiltinArguments& args) { |
| /* Enable property triggers. */ |
| property_triggers_enabled = 1; |
| return Success(); |
| } |
| |
| static Result<Success> queue_property_triggers_action(const BuiltinArguments& args) { |
| ActionManager::GetInstance().QueueBuiltinAction(property_enable_triggers_action, "enable_property_trigger"); |
| ActionManager::GetInstance().QueueAllPropertyActions(); |
| return Success(); |
| } |
| |
| static void global_seccomp() { |
| import_kernel_cmdline(false, [](const std::string& key, const std::string& value, bool in_qemu) { |
| if (key == "androidboot.seccomp" && value == "global" && !set_global_seccomp_filter()) { |
| LOG(FATAL) << "Failed to globally enable seccomp!"; |
| } |
| }); |
| } |
| |
| // Set the UDC controller for the ConfigFS USB Gadgets. |
| // Read the UDC controller in use from "/sys/class/udc". |
| // In case of multiple UDC controllers select the first one. |
| static void set_usb_controller() { |
| std::unique_ptr<DIR, decltype(&closedir)>dir(opendir("/sys/class/udc"), closedir); |
| if (!dir) return; |
| |
| dirent* dp; |
| while ((dp = readdir(dir.get())) != nullptr) { |
| if (dp->d_name[0] == '.') continue; |
| |
| property_set("sys.usb.controller", dp->d_name); |
| break; |
| } |
| } |
| |
| static void InstallRebootSignalHandlers() { |
| // Instead of panic'ing the kernel as is the default behavior when init crashes, |
| // we prefer to reboot to bootloader on development builds, as this will prevent |
| // boot looping bad configurations and allow both developers and test farms to easily |
| // recover. |
| struct sigaction action; |
| memset(&action, 0, sizeof(action)); |
| sigfillset(&action.sa_mask); |
| action.sa_handler = [](int signal) { |
| // These signal handlers are also caught for processes forked from init, however we do not |
| // want them to trigger reboot, so we directly call _exit() for children processes here. |
| if (getpid() != 1) { |
| _exit(signal); |
| } |
| |
| // Calling DoReboot() or LOG(FATAL) is not a good option as this is a signal handler. |
| // RebootSystem uses syscall() which isn't actually async-signal-safe, but our only option |
| // and probably good enough given this is already an error case and only enabled for |
| // development builds. |
| RebootSystem(ANDROID_RB_RESTART2, "bootloader"); |
| }; |
| action.sa_flags = SA_RESTART; |
| sigaction(SIGABRT, &action, nullptr); |
| sigaction(SIGBUS, &action, nullptr); |
| sigaction(SIGFPE, &action, nullptr); |
| sigaction(SIGILL, &action, nullptr); |
| sigaction(SIGSEGV, &action, nullptr); |
| #if defined(SIGSTKFLT) |
| sigaction(SIGSTKFLT, &action, nullptr); |
| #endif |
| sigaction(SIGSYS, &action, nullptr); |
| sigaction(SIGTRAP, &action, nullptr); |
| } |
| |
| static void HandleSigtermSignal(const signalfd_siginfo& siginfo) { |
| if (siginfo.ssi_pid != 0) { |
| // Drop any userspace SIGTERM requests. |
| LOG(DEBUG) << "Ignoring SIGTERM from pid " << siginfo.ssi_pid; |
| return; |
| } |
| |
| HandlePowerctlMessage("shutdown,container"); |
| } |
| |
| static void HandleSignalFd() { |
| signalfd_siginfo siginfo; |
| ssize_t bytes_read = TEMP_FAILURE_RETRY(read(signal_fd, &siginfo, sizeof(siginfo))); |
| if (bytes_read != sizeof(siginfo)) { |
| PLOG(ERROR) << "Failed to read siginfo from signal_fd"; |
| return; |
| } |
| |
| switch (siginfo.ssi_signo) { |
| case SIGCHLD: |
| ReapAnyOutstandingChildren(); |
| break; |
| case SIGTERM: |
| HandleSigtermSignal(siginfo); |
| break; |
| default: |
| PLOG(ERROR) << "signal_fd: received unexpected signal " << siginfo.ssi_signo; |
| break; |
| } |
| } |
| |
| static void UnblockSignals() { |
| const struct sigaction act { .sa_handler = SIG_DFL }; |
| sigaction(SIGCHLD, &act, nullptr); |
| |
| sigset_t mask; |
| sigemptyset(&mask); |
| sigaddset(&mask, SIGCHLD); |
| sigaddset(&mask, SIGTERM); |
| |
| if (sigprocmask(SIG_UNBLOCK, &mask, nullptr) == -1) { |
| PLOG(FATAL) << "failed to unblock signals for PID " << getpid(); |
| } |
| } |
| |
| static void InstallSignalFdHandler(Epoll* epoll) { |
| // Applying SA_NOCLDSTOP to a defaulted SIGCHLD handler prevents the signalfd from receiving |
| // SIGCHLD when a child process stops or continues (b/77867680#comment9). |
| const struct sigaction act { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDSTOP }; |
| sigaction(SIGCHLD, &act, nullptr); |
| |
| sigset_t mask; |
| sigemptyset(&mask); |
| sigaddset(&mask, SIGCHLD); |
| |
| if (!IsRebootCapable()) { |
| // If init does not have the CAP_SYS_BOOT capability, it is running in a container. |
| // In that case, receiving SIGTERM will cause the system to shut down. |
| sigaddset(&mask, SIGTERM); |
| } |
| |
| if (sigprocmask(SIG_BLOCK, &mask, nullptr) == -1) { |
| PLOG(FATAL) << "failed to block signals"; |
| } |
| |
| // Register a handler to unblock signals in the child processes. |
| const int result = pthread_atfork(nullptr, nullptr, &UnblockSignals); |
| if (result != 0) { |
| LOG(FATAL) << "Failed to register a fork handler: " << strerror(result); |
| } |
| |
| signal_fd = signalfd(-1, &mask, SFD_CLOEXEC); |
| if (signal_fd == -1) { |
| PLOG(FATAL) << "failed to create signalfd"; |
| } |
| |
| if (auto result = epoll->RegisterHandler(signal_fd, HandleSignalFd); !result) { |
| LOG(FATAL) << result.error(); |
| } |
| } |
| |
| void HandleKeychord(const std::vector<int>& keycodes) { |
| // Only handle keychords if adb is enabled. |
| std::string adb_enabled = android::base::GetProperty("init.svc.adbd", ""); |
| if (adb_enabled != "running") { |
| LOG(WARNING) << "Not starting service for keychord " << android::base::Join(keycodes, ' ') |
| << " because ADB is disabled"; |
| return; |
| } |
| |
| auto found = false; |
| for (const auto& service : ServiceList::GetInstance()) { |
| auto svc = service.get(); |
| if (svc->keycodes() == keycodes) { |
| found = true; |
| LOG(INFO) << "Starting service '" << svc->name() << "' from keychord " |
| << android::base::Join(keycodes, ' '); |
| if (auto result = svc->Start(); !result) { |
| LOG(ERROR) << "Could not start service '" << svc->name() << "' from keychord " |
| << android::base::Join(keycodes, ' ') << ": " << result.error(); |
| } |
| } |
| } |
| if (!found) { |
| LOG(ERROR) << "Service for keychord " << android::base::Join(keycodes, ' ') << " not found"; |
| } |
| } |
| |
| int main(int argc, char** argv) { |
| if (!strcmp(basename(argv[0]), "ueventd")) { |
| return ueventd_main(argc, argv); |
| } |
| |
| if (!strcmp(basename(argv[0]), "watchdogd")) { |
| return watchdogd_main(argc, argv); |
| } |
| |
| if (argc > 1 && !strcmp(argv[1], "subcontext")) { |
| InitKernelLogging(argv); |
| const BuiltinFunctionMap function_map; |
| return SubcontextMain(argc, argv, &function_map); |
| } |
| |
| if (REBOOT_BOOTLOADER_ON_PANIC) { |
| InstallRebootSignalHandlers(); |
| } |
| |
| bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr); |
| |
| if (is_first_stage) { |
| boot_clock::time_point start_time = boot_clock::now(); |
| |
| std::vector<std::pair<std::string, int>> errors; |
| #define CHECKCALL(x) \ |
| if (x != 0) errors.emplace_back(#x " failed", errno); |
| |
| // Clear the umask. |
| umask(0); |
| |
| CHECKCALL(clearenv()); |
| CHECKCALL(setenv("PATH", _PATH_DEFPATH, 1)); |
| // Get the basic filesystem setup we need put together in the initramdisk |
| // on / and then we'll let the rc file figure out the rest. |
| CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755")); |
| CHECKCALL(mkdir("/dev/pts", 0755)); |
| CHECKCALL(mkdir("/dev/socket", 0755)); |
| CHECKCALL(mount("devpts", "/dev/pts", "devpts", 0, NULL)); |
| #define MAKE_STR(x) __STRING(x) |
| CHECKCALL(mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC))); |
| #undef MAKE_STR |
| // Don't expose the raw commandline to unprivileged processes. |
| CHECKCALL(chmod("/proc/cmdline", 0440)); |
| gid_t groups[] = { AID_READPROC }; |
| CHECKCALL(setgroups(arraysize(groups), groups)); |
| CHECKCALL(mount("sysfs", "/sys", "sysfs", 0, NULL)); |
| CHECKCALL(mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL)); |
| |
| CHECKCALL(mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11))); |
| |
| if constexpr (WORLD_WRITABLE_KMSG) { |
| CHECKCALL(mknod("/dev/kmsg_debug", S_IFCHR | 0622, makedev(1, 11))); |
| } |
| |
| CHECKCALL(mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8))); |
| CHECKCALL(mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9))); |
| |
| // Mount staging areas for devices managed by vold |
| // See storage config details at http://source.android.com/devices/storage/ |
| CHECKCALL(mount("tmpfs", "/mnt", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV, |
| "mode=0755,uid=0,gid=1000")); |
| // /mnt/vendor is used to mount vendor-specific partitions that can not be |
| // part of the vendor partition, e.g. because they are mounted read-write. |
| CHECKCALL(mkdir("/mnt/vendor", 0755)); |
| // /mnt/product is used to mount product-specific partitions that can not be |
| // part of the product partition, e.g. because they are mounted read-write. |
| CHECKCALL(mkdir("/mnt/product", 0755)); |
| |
| #undef CHECKCALL |
| |
| // Now that tmpfs is mounted on /dev and we have /dev/kmsg, we can actually |
| // talk to the outside world... |
| InitKernelLogging(argv); |
| |
| if (!errors.empty()) { |
| for (const auto& [error_string, error_errno] : errors) { |
| LOG(ERROR) << error_string << " " << strerror(error_errno); |
| } |
| LOG(FATAL) << "Init encountered errors starting first stage, aborting"; |
| } |
| |
| LOG(INFO) << "init first stage started!"; |
| |
| if (!DoFirstStageMount()) { |
| LOG(FATAL) << "Failed to mount required partitions early ..."; |
| } |
| |
| SetInitAvbVersionInRecovery(); |
| |
| // Enable seccomp if global boot option was passed (otherwise it is enabled in zygote). |
| global_seccomp(); |
| |
| // Set up SELinux, loading the SELinux policy. |
| SelinuxSetupKernelLogging(); |
| SelinuxInitialize(); |
| |
| // We're in the kernel domain, so re-exec init to transition to the init domain now |
| // that the SELinux policy has been loaded. |
| if (selinux_android_restorecon("/init", 0) == -1) { |
| PLOG(FATAL) << "restorecon failed of /init failed"; |
| } |
| |
| setenv("INIT_SECOND_STAGE", "true", 1); |
| |
| static constexpr uint32_t kNanosecondsPerMillisecond = 1e6; |
| uint64_t start_ms = start_time.time_since_epoch().count() / kNanosecondsPerMillisecond; |
| setenv("INIT_STARTED_AT", std::to_string(start_ms).c_str(), 1); |
| |
| char* path = argv[0]; |
| char* args[] = { path, nullptr }; |
| execv(path, args); |
| |
| // execv() only returns if an error happened, in which case we |
| // panic and never fall through this conditional. |
| PLOG(FATAL) << "execv(\"" << path << "\") failed"; |
| } |
| |
| // At this point we're in the second stage of init. |
| InitKernelLogging(argv); |
| LOG(INFO) << "init second stage started!"; |
| |
| // Set up a session keyring that all processes will have access to. It |
| // will hold things like FBE encryption keys. No process should override |
| // its session keyring. |
| keyctl_get_keyring_ID(KEY_SPEC_SESSION_KEYRING, 1); |
| |
| // Indicate that booting is in progress to background fw loaders, etc. |
| close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000)); |
| |
| property_init(); |
| |
| // If arguments are passed both on the command line and in DT, |
| // properties set in DT always have priority over the command-line ones. |
| process_kernel_dt(); |
| process_kernel_cmdline(); |
| |
| // Propagate the kernel variables to internal variables |
| // used by init as well as the current required properties. |
| export_kernel_boot_props(); |
| |
| // Make the time that init started available for bootstat to log. |
| property_set("ro.boottime.init", getenv("INIT_STARTED_AT")); |
| property_set("ro.boottime.init.selinux", getenv("INIT_SELINUX_TOOK")); |
| |
| // Set libavb version for Framework-only OTA match in Treble build. |
| const char* avb_version = getenv("INIT_AVB_VERSION"); |
| if (avb_version) property_set("ro.boot.avb_version", avb_version); |
| |
| // Clean up our environment. |
| unsetenv("INIT_SECOND_STAGE"); |
| unsetenv("INIT_STARTED_AT"); |
| unsetenv("INIT_SELINUX_TOOK"); |
| unsetenv("INIT_AVB_VERSION"); |
| |
| // Now set up SELinux for second stage. |
| SelinuxSetupKernelLogging(); |
| SelabelInitialize(); |
| SelinuxRestoreContext(); |
| |
| Epoll epoll; |
| if (auto result = epoll.Open(); !result) { |
| PLOG(FATAL) << result.error(); |
| } |
| |
| InstallSignalFdHandler(&epoll); |
| |
| property_load_boot_defaults(); |
| export_oem_lock_status(); |
| StartPropertyService(&epoll); |
| set_usb_controller(); |
| |
| const BuiltinFunctionMap function_map; |
| Action::set_function_map(&function_map); |
| |
| subcontexts = InitializeSubcontexts(); |
| |
| ActionManager& am = ActionManager::GetInstance(); |
| ServiceList& sm = ServiceList::GetInstance(); |
| |
| LoadBootScripts(am, sm); |
| |
| // Turning this on and letting the INFO logging be discarded adds 0.2s to |
| // Nexus 9 boot time, so it's disabled by default. |
| if (false) DumpState(); |
| |
| 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"); |
| am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict"); |
| Keychords keychords; |
| am.QueueBuiltinAction( |
| [&epoll, &keychords](const BuiltinArguments& args) -> Result<Success> { |
| for (const auto& svc : ServiceList::GetInstance()) { |
| keychords.Register(svc->keycodes()); |
| } |
| keychords.Start(&epoll, HandleKeychord); |
| return Success(); |
| }, |
| "KeychordInit"); |
| am.QueueBuiltinAction(console_init_action, "console_init"); |
| |
| // Trigger all the boot actions to get us started. |
| am.QueueEventTrigger("init"); |
| |
| // Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random |
| // wasn't ready immediately after wait_for_coldboot_done |
| am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng"); |
| |
| // Don't mount filesystems or start core system services in charger mode. |
| std::string bootmode = GetProperty("ro.bootmode", ""); |
| if (bootmode == "charger") { |
| am.QueueEventTrigger("charger"); |
| } else { |
| am.QueueEventTrigger("late-init"); |
| } |
| |
| // Run all property triggers based on current state of the properties. |
| am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers"); |
| |
| while (true) { |
| // By default, sleep until something happens. |
| auto epoll_timeout = std::optional<std::chrono::milliseconds>{}; |
| |
| if (do_shutdown && !shutting_down) { |
| do_shutdown = false; |
| if (HandlePowerctlMessage(shutdown_command)) { |
| shutting_down = true; |
| } |
| } |
| |
| if (!(waiting_for_prop || Service::is_exec_service_running())) { |
| am.ExecuteOneCommand(); |
| } |
| if (!(waiting_for_prop || Service::is_exec_service_running())) { |
| if (!shutting_down) { |
| auto next_process_restart_time = RestartProcesses(); |
| |
| // If there's a process that needs restarting, wake up in time for that. |
| if (next_process_restart_time) { |
| epoll_timeout = std::chrono::ceil<std::chrono::milliseconds>( |
| *next_process_restart_time - boot_clock::now()); |
| if (*epoll_timeout < 0ms) epoll_timeout = 0ms; |
| } |
| } |
| |
| // If there's more work to do, wake up again immediately. |
| if (am.HasMoreCommands()) epoll_timeout = 0ms; |
| } |
| |
| if (auto result = epoll.Wait(epoll_timeout); !result) { |
| LOG(ERROR) << result.error(); |
| } |
| } |
| |
| return 0; |
| } |
| |
| } // namespace init |
| } // namespace android |