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