blob: 645184b26967fa8773b1abef15aeb8673f40e511 [file] [log] [blame]
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -07001/*
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 Cherry3f5eaae52017-04-06 16:30:22 -070017#include "init.h"
18
Rom Lemarchand6a524432015-02-28 06:39:11 -080019#include <dirent.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080020#include <fcntl.h>
Elliott Hughescc86fb22015-03-17 20:01:13 -070021#include <paths.h>
yusukes4a4ec14e2018-02-01 17:14:30 -080022#include <pthread.h>
Steve Muckleaf1a9bf2017-07-17 15:14:02 -070023#include <seccomp_policy.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080024#include <signal.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070025#include <stdlib.h>
26#include <string.h>
Elliott Hughes929f4072015-04-24 21:13:44 -070027#include <sys/epoll.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070028#include <sys/mount.h>
Luis Hector Chavez9f97f472017-09-06 13:43:57 -070029#include <sys/signalfd.h>
Elliott Hughes35f5d042016-07-26 09:32:33 -070030#include <sys/sysmacros.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080031#include <sys/types.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080032#include <unistd.h>
33
Tom Cherry8ae73752018-05-01 13:39:52 -070034#include <map>
35#include <memory>
36#include <optional>
37
James Hawkinse78ea772017-03-24 11:43:02 -070038#include <android-base/chrono_utils.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080039#include <android-base/file.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070040#include <android-base/logging.h>
Tom Cherryccf23532017-03-28 16:40:41 -070041#include <android-base/properties.h>
Tom Cherry6f2d56d2018-02-21 10:37:44 -080042#include <android-base/stringprintf.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080043#include <android-base/strings.h>
Tom Cherryd8db7ab2017-08-17 17:28:30 -070044#include <cutils/android_reboot.h>
Elliott Hughesf8627ce2017-05-09 17:09:06 -070045#include <keyutils.h>
bowgotsai76351272017-02-14 22:06:20 +080046#include <libavb/libavb.h>
Colin Crossf83d0b92010-04-21 12:04:20 -070047#include <private/android_filesystem_config.h>
Elliott Hughesf8627ce2017-05-09 17:09:06 -070048#include <selinux/android.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070049
Tom Cherry0f6417f2018-02-13 15:25:29 -080050#include "action_parser.h"
Tom Cherryb7349902015-08-26 11:43:36 -070051#include "import_parser.h"
Bowgo Tsaid2620172017-04-17 22:17:09 +080052#include "init_first_stage.h"
Tom Cherrybac32992015-07-31 12:45:25 -070053#include "keychords.h"
Colin Crossed8a7d82010-04-19 17:05:34 -070054#include "log.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070055#include "property_service.h"
Tom Cherry98ad32a2017-04-17 16:34:20 -070056#include "reboot.h"
Tom Cherry0c8d6d22017-08-10 12:22:44 -070057#include "security.h"
58#include "selinux.h"
Luis Hector Chavez9f97f472017-09-06 13:43:57 -070059#include "sigchld_handler.h"
Colin Crossf83d0b92010-04-21 12:04:20 -070060#include "ueventd.h"
Tom Cherrybac32992015-07-31 12:45:25 -070061#include "util.h"
Arve Hjønnevågd97d9072012-06-13 21:51:56 -070062#include "watchdogd.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070063
Tom Cherry1c3a53f2017-06-22 16:50:31 -070064using namespace std::string_literals;
65
James Hawkinse78ea772017-03-24 11:43:02 -070066using android::base::boot_clock;
Tom Cherryccf23532017-03-28 16:40:41 -070067using android::base::GetProperty;
Tom Cherry6f2d56d2018-02-21 10:37:44 -080068using android::base::ReadFileToString;
69using android::base::StringPrintf;
Tom Cherryede0d532017-07-06 14:20:11 -070070using android::base::Timer;
Tom Cherry6f2d56d2018-02-21 10:37:44 -080071using android::base::Trim;
Elliott Hughes9605a942016-11-10 17:43:47 -080072
Tom Cherry81f5d3e2017-06-22 12:53:17 -070073namespace android {
74namespace init {
75
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070076static int property_triggers_enabled = 0;
77
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070078static char qemu[32];
79
Viorel Suman70daa672016-03-21 10:08:07 +020080std::string default_console = "/dev/console";
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070081
Elliott Hughes929f4072015-04-24 21:13:44 -070082static int epoll_fd = -1;
Ryan Prichard1325ec82018-04-11 18:46:38 -070083static int signal_fd = -1;
Elliott Hughes929f4072015-04-24 21:13:44 -070084
Wei Wang132ac312017-01-25 16:27:03 -080085static std::unique_ptr<Timer> waiting_for_prop(nullptr);
86static std::string wait_prop_name;
87static std::string wait_prop_value;
Wei Wangeeab4912017-06-27 22:08:45 -070088static bool shutting_down;
Tom Cherry3633a402017-09-13 14:39:45 -070089static std::string shutdown_command;
90static bool do_shutdown = false;
Wei Wang132ac312017-01-25 16:27:03 -080091
Tom Cherry67dee622017-07-27 12:54:48 -070092std::vector<std::string> late_import_paths;
93
Tom Cherrycb0f9bb2017-09-12 15:58:47 -070094static std::vector<Subcontext>* subcontexts;
95
Tom Cherry30a6f272017-04-19 15:31:58 -070096void DumpState() {
Tom Cherry911b9b12017-07-27 16:20:58 -070097 ServiceList::GetInstance().DumpState();
Tom Cherry30a6f272017-04-19 15:31:58 -070098 ActionManager::GetInstance().DumpState();
99}
100
Tom Cherry911b9b12017-07-27 16:20:58 -0700101Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {
Tom Cherry67dee622017-07-27 12:54:48 -0700102 Parser parser;
103
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700104 parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, subcontexts));
105 parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, subcontexts));
Tom Cherry67dee622017-07-27 12:54:48 -0700106 parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
107
108 return parser;
109}
110
Tom Cherry911b9b12017-07-27 16:20:58 -0700111static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
112 Parser parser = CreateParser(action_manager, service_list);
Tom Cherry67dee622017-07-27 12:54:48 -0700113
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 Seokdff165d2017-11-28 12:10:10 +0900120 if (!parser.ParseConfig("/product/etc/init")) {
121 late_import_paths.emplace_back("/product/etc/init");
Tom Cherry67dee622017-07-27 12:54:48 -0700122 }
123 if (!parser.ParseConfig("/odm/etc/init")) {
124 late_import_paths.emplace_back("/odm/etc/init");
125 }
Jaekyun Seokdff165d2017-11-28 12:10:10 +0900126 if (!parser.ParseConfig("/vendor/etc/init")) {
127 late_import_paths.emplace_back("/vendor/etc/init");
128 }
Tom Cherry67dee622017-07-27 12:54:48 -0700129 } else {
130 parser.ParseConfig(bootscript);
131 }
132}
133
Tom Cherry8ae73752018-05-01 13:39:52 -0700134static std::map<int, std::function<void()>> epoll_handlers;
135
136void 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 Hughes929f4072015-04-24 21:13:44 -0700142 epoll_event ev;
143 ev.events = EPOLLIN;
Tom Cherry8ae73752018-05-01 13:39:52 -0700144 // 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 Hughes929f4072015-04-24 21:13:44 -0700147 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
Tom Cherry8ae73752018-05-01 13:39:52 -0700148 PLOG(ERROR) << "epoll_ctl failed to add fd";
149 epoll_handlers.erase(fd);
150 }
151}
152
153void 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 Hughes929f4072015-04-24 21:13:44 -0700159 }
160}
161
Wei Wang2d0fdaa2017-02-02 10:52:39 -0800162bool start_waiting_for_property(const char *name, const char *value)
Wei Wang132ac312017-01-25 16:27:03 -0800163{
164 if (waiting_for_prop) {
165 return false;
166 }
Tom Cherryccf23532017-03-28 16:40:41 -0700167 if (GetProperty(name, "") != value) {
Wei Wang132ac312017-01-25 16:27:03 -0800168 // 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 Wang2d0fdaa2017-02-02 10:52:39 -0800173 LOG(INFO) << "start_waiting_for_property(\""
174 << name << "\", \"" << value << "\"): already set";
Wei Wang132ac312017-01-25 16:27:03 -0800175 }
176 return true;
177}
178
Wei Wangeeab4912017-06-27 22:08:45 -0700179void ResetWaitForProp() {
180 wait_prop_name.clear();
181 wait_prop_value.clear();
182 waiting_for_prop.reset();
183}
184
Tom Cherry98ad32a2017-04-17 16:34:20 -0700185void 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 Wangeeab4912017-06-27 22:08:45 -0700190 // 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 Cherry3633a402017-09-13 14:39:45 -0700193 // 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 Wangeeab4912017-06-27 22:08:45 -0700203 }
Tom Cherry98ad32a2017-04-17 16:34:20 -0700204
Tom Cherry26ed9cb2017-04-17 13:25:29 -0700205 if (property_triggers_enabled) ActionManager::GetInstance().QueuePropertyChange(name, value);
206
Wei Wang132ac312017-01-25 16:27:03 -0800207 if (waiting_for_prop) {
208 if (wait_prop_name == name && wait_prop_value == value) {
Wei Wang132ac312017-01-25 16:27:03 -0800209 LOG(INFO) << "Wait for property took " << *waiting_for_prop;
Wei Wangeeab4912017-06-27 22:08:45 -0700210 ResetWaitForProp();
Wei Wang132ac312017-01-25 16:27:03 -0800211 }
212 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700213}
214
Tom Cherryd269e3a2017-07-31 13:23:18 -0700215static std::optional<boot_clock::time_point> RestartProcesses() {
216 std::optional<boot_clock::time_point> next_process_restart_time;
Tom Cherry911b9b12017-07-27 16:20:58 -0700217 for (const auto& s : ServiceList::GetInstance()) {
218 if (!(s->flags() & SVC_RESTARTING)) continue;
Tom Cherryd269e3a2017-07-31 13:23:18 -0700219
220 auto restart_time = s->time_started() + 5s;
221 if (boot_clock::now() > restart_time) {
Tom Cherry702ca9a2017-08-25 10:36:52 -0700222 if (auto result = s->Start(); !result) {
223 LOG(ERROR) << "Could not restart process '" << s->name() << "': " << result.error();
224 }
Tom Cherryd269e3a2017-07-31 13:23:18 -0700225 } else {
226 if (!next_process_restart_time || restart_time < *next_process_restart_time) {
227 next_process_restart_time = restart_time;
228 }
229 }
Tom Cherry911b9b12017-07-27 16:20:58 -0700230 }
Tom Cherryd269e3a2017-07-31 13:23:18 -0700231 return next_process_restart_time;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700232}
233
Steven Morelande055d732017-10-05 18:50:22 -0700234static Result<Success> DoControlStart(Service* service) {
235 return service->Start();
236}
237
238static Result<Success> DoControlStop(Service* service) {
239 service->Stop();
240 return Success();
241}
242
243static Result<Success> DoControlRestart(Service* service) {
244 service->Restart();
245 return Success();
246}
247
248enum 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
253struct ControlMessageFunction {
254 ControlTarget target;
255 std::function<Result<Success>(Service*)> action;
256};
257
258static 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 Cherry8f380482018-04-17 14:48:44 -0700261 {"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 Morelande055d732017-10-05 18:50:22 -0700265 {"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 Cherry6f2d56d2018-02-21 10:37:44 -0800277void HandleControlMessage(const std::string& msg, const std::string& name, pid_t pid) {
Steven Morelande055d732017-10-05 18:50:22 -0700278 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 Hughesbdeac392016-04-12 15:38:27 -0700283 return;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700284 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700285
Tom Cherry6f2d56d2018-02-21 10:37:44 -0800286 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 Morelande055d732017-10-05 18:50:22 -0700298 const ControlMessageFunction& function = it->second;
299
Steven Moreland6227e342018-05-08 13:46:39 -0700300 Service* svc = nullptr;
Steven Morelande055d732017-10-05 18:50:22 -0700301
Steven Moreland6227e342018-05-08 13:46:39 -0700302 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 Morelande055d732017-10-05 18:50:22 -0700317 return;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700318 }
Steven Morelande055d732017-10-05 18:50:22 -0700319
Steven Moreland6227e342018-05-08 13:46:39 -0700320 if (auto result = function.action(svc); !result) {
321 LOG(ERROR) << "Could not ctl." << msg << " for '" << name << "': " << result.error();
Steven Morelande055d732017-10-05 18:50:22 -0700322 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700323}
324
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700325static Result<Success> wait_for_coldboot_done_action(const BuiltinArguments& args) {
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700326 Timer t;
327
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700328 LOG(VERBOSE) << "Waiting for " COLDBOOT_DONE "...";
Elliott Hughes331cf2f2016-11-29 19:20:58 +0000329
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 Cherryd8db7ab2017-08-17 17:28:30 -0700339 LOG(FATAL) << "Timed out waiting for " COLDBOOT_DONE;
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700340 }
341
Tom Cherryede0d532017-07-06 14:20:11 -0700342 property_set("ro.boottime.init.cold_boot_wait", std::to_string(t.duration().count()));
Tom Cherry557946e2017-08-01 13:50:23 -0700343 return Success();
Colin Crossebc6ff12010-04-13 19:52:01 -0700344}
345
Mark Salyzyn353bf1f2018-04-30 07:33:31 -0700346static Result<Success> KeychordInitAction(const BuiltinArguments& args) {
347 KeychordInit();
Tom Cherry557946e2017-08-01 13:50:23 -0700348 return Success();
Colin Crossebc6ff12010-04-13 19:52:01 -0700349}
350
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700351static Result<Success> console_init_action(const BuiltinArguments& args) {
Tom Cherryccf23532017-03-28 16:40:41 -0700352 std::string console = GetProperty("ro.boot.console", "");
Viorel Sumanefc72752016-03-21 10:23:43 +0200353 if (!console.empty()) {
Viorel Suman70daa672016-03-21 10:08:07 +0200354 default_console = "/dev/" + console;
Colin Crossebc6ff12010-04-13 19:52:01 -0700355 }
Tom Cherry557946e2017-08-01 13:50:23 -0700356 return Success();
Colin Crossebc6ff12010-04-13 19:52:01 -0700357}
358
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700359static void import_kernel_nv(const std::string& key, const std::string& value, bool for_emulator) {
360 if (key.empty()) return;
Dima Zavin5511c842011-12-19 11:21:32 -0800361
362 if (for_emulator) {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700363 // In the emulator, export any kernel option with the "ro.kernel." prefix.
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700364 property_set("ro.kernel." + key, value);
Dima Zavin5511c842011-12-19 11:21:32 -0800365 return;
366 }
367
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700368 if (key == "qemu") {
369 strlcpy(qemu, value.c_str(), sizeof(qemu));
370 } else if (android::base::StartsWith(key, "androidboot.")) {
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700371 property_set("ro.boot." + key.substr(12), value);
Dima Zavin5511c842011-12-19 11:21:32 -0800372 }
373}
374
Sami Tolvanen9e9efca2015-12-07 12:33:58 +0000375static void export_oem_lock_status() {
Tom Cherryccf23532017-03-28 16:40:41 -0700376 if (!android::base::GetBoolProperty("ro.oem_unlock_supported", false)) {
Sami Tolvanen9e9efca2015-12-07 12:33:58 +0000377 return;
378 }
379
Tom Cherryccf23532017-03-28 16:40:41 -0700380 std::string value = GetProperty("ro.boot.verifiedbootstate", "");
Sami Tolvanen9e9efca2015-12-07 12:33:58 +0000381
382 if (!value.empty()) {
383 property_set("ro.boot.flash.locked", value == "orange" ? "0" : "1");
384 }
385}
386
Elliott Hughesd679bc92015-03-20 08:50:46 -0700387static void export_kernel_boot_props() {
Dima Zavin5511c842011-12-19 11:21:32 -0800388 struct {
389 const char *src_prop;
Elliott Hughesd679bc92015-03-20 08:50:46 -0700390 const char *dst_prop;
391 const char *default_value;
Dima Zavin5511c842011-12-19 11:21:32 -0800392 } prop_map[] = {
Elliott Hughesd679bc92015-03-20 08:50:46 -0700393 { "ro.boot.serialno", "ro.serialno", "", },
394 { "ro.boot.mode", "ro.bootmode", "unknown", },
395 { "ro.boot.baseband", "ro.baseband", "unknown", },
Dima Zavin5511c842011-12-19 11:21:32 -0800396 { "ro.boot.bootloader", "ro.bootloader", "unknown", },
Elliott Hughesd679bc92015-03-20 08:50:46 -0700397 { "ro.boot.hardware", "ro.hardware", "unknown", },
398 { "ro.boot.revision", "ro.revision", "0", },
Dima Zavin5511c842011-12-19 11:21:32 -0800399 };
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700400 for (size_t i = 0; i < arraysize(prop_map); i++) {
Tom Cherryccf23532017-03-28 16:40:41 -0700401 std::string value = GetProperty(prop_map[i].src_prop, "");
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700402 property_set(prop_map[i].dst_prop, (!value.empty()) ? value : prop_map[i].default_value);
Dima Zavin5511c842011-12-19 11:21:32 -0800403 }
Dima Zavin5511c842011-12-19 11:21:32 -0800404}
Colin Crossebc6ff12010-04-13 19:52:01 -0700405
Sandeep Patilfc86f242017-02-09 19:19:31 -0800406static void process_kernel_dt() {
Bowgo Tsaid2620172017-04-17 22:17:09 +0800407 if (!is_android_dt_value_expected("compatible", "android,firmware")) {
408 return;
409 }
Sandeep Patilfc86f242017-02-09 19:19:31 -0800410
Yu Ningc01022a2017-07-26 17:54:08 +0800411 std::unique_ptr<DIR, int (*)(DIR*)> dir(opendir(get_android_dt_dir().c_str()), closedir);
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700412 if (!dir) return;
Rom Lemarchand6a524432015-02-28 06:39:11 -0800413
Sandeep Patilfc86f242017-02-09 19:19:31 -0800414 std::string dt_file;
Rom Lemarchand6a524432015-02-28 06:39:11 -0800415 struct dirent *dp;
416 while ((dp = readdir(dir.get())) != NULL) {
Rom Lemarchand1dcf3252015-11-08 17:51:50 -0800417 if (dp->d_type != DT_REG || !strcmp(dp->d_name, "compatible") || !strcmp(dp->d_name, "name")) {
Rom Lemarchand6a524432015-02-28 06:39:11 -0800418 continue;
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700419 }
Rom Lemarchand6a524432015-02-28 06:39:11 -0800420
Yu Ningc01022a2017-07-26 17:54:08 +0800421 std::string file_name = get_android_dt_dir() + dp->d_name;
Rom Lemarchand6a524432015-02-28 06:39:11 -0800422
423 android::base::ReadFileToString(file_name, &dt_file);
424 std::replace(dt_file.begin(), dt_file.end(), ',', '.');
425
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700426 property_set("ro.boot."s + dp->d_name, dt_file);
Rom Lemarchand6a524432015-02-28 06:39:11 -0800427 }
428}
429
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700430static void process_kernel_cmdline() {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700431 // 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 Kralevichf667a322015-04-25 17:42:52 -0700434 import_kernel_cmdline(false, import_kernel_nv);
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700435 if (qemu[0]) import_kernel_cmdline(true, import_kernel_nv);
Colin Crossebc6ff12010-04-13 19:52:01 -0700436}
437
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700438static Result<Success> property_enable_triggers_action(const BuiltinArguments& args) {
caozhiyuanb104c502016-11-26 21:14:07 +0800439 /* Enable property triggers. */
440 property_triggers_enabled = 1;
Tom Cherry557946e2017-08-01 13:50:23 -0700441 return Success();
caozhiyuanb104c502016-11-26 21:14:07 +0800442}
443
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700444static Result<Success> queue_property_triggers_action(const BuiltinArguments& args) {
caozhiyuanb104c502016-11-26 21:14:07 +0800445 ActionManager::GetInstance().QueueBuiltinAction(property_enable_triggers_action, "enable_property_trigger");
Tom Cherry26ed9cb2017-04-17 13:25:29 -0700446 ActionManager::GetInstance().QueueAllPropertyActions();
Tom Cherry557946e2017-08-01 13:50:23 -0700447 return Success();
Colin Crossebc6ff12010-04-13 19:52:01 -0700448}
449
Steve Muckleaf1a9bf2017-07-17 15:14:02 -0700450static 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 Cherryd8db7ab2017-08-17 17:28:30 -0700453 LOG(FATAL) << "Failed to globally enable seccomp!";
Steve Muckleaf1a9bf2017-07-17 15:14:02 -0700454 }
455 });
456}
457
Amit Pundird2e74db2016-06-29 19:00:00 +0530458// 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.
461static 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 Cherry1ca83242017-08-25 15:10:48 -0700474static void InstallRebootSignalHandlers() {
Tom Cherry663fdfc2017-03-10 14:46:38 -0800475 // 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 Cherry1ca83242017-08-25 15:10:48 -0700482 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 Cherryd8db7ab2017-08-17 17:28:30 -0700489 // 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 Cherry663fdfc2017-03-10 14:46:38 -0800494 };
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 Prichard1325ec82018-04-11 18:46:38 -0700508static void HandleSigtermSignal(const signalfd_siginfo& siginfo) {
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700509 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 Salyzyn161b8622017-09-26 08:26:12 -0700515 HandlePowerctlMessage("shutdown,container");
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700516}
517
Ryan Prichard1325ec82018-04-11 18:46:38 -0700518static 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 }
yusukes4a4ec14e2018-02-01 17:14:30 -0800525
Ryan Prichard1325ec82018-04-11 18:46:38 -0700526 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;
yusukes4a4ec14e2018-02-01 17:14:30 -0800536 }
537}
538
Ryan Prichard1325ec82018-04-11 18:46:38 -0700539static void UnblockSignals() {
540 const struct sigaction act { .sa_handler = SIG_DFL };
541 sigaction(SIGCHLD, &act, nullptr);
542
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700543 sigset_t mask;
544 sigemptyset(&mask);
Ryan Prichard1325ec82018-04-11 18:46:38 -0700545 sigaddset(&mask, SIGCHLD);
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700546 sigaddset(&mask, SIGTERM);
547
Ryan Prichard1325ec82018-04-11 18:46:38 -0700548 if (sigprocmask(SIG_UNBLOCK, &mask, nullptr) == -1) {
549 PLOG(FATAL) << "failed to unblock signals for PID " << getpid();
550 }
551}
552
553static 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 Chavez9f97f472017-09-06 13:43:57 -0700567 }
568
Ryan Prichard1325ec82018-04-11 18:46:38 -0700569 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);
yusukes4a4ec14e2018-02-01 17:14:30 -0800575 if (result != 0) {
576 LOG(FATAL) << "Failed to register a fork handler: " << strerror(result);
577 }
578
Ryan Prichard1325ec82018-04-11 18:46:38 -0700579 signal_fd = signalfd(-1, &mask, SFD_CLOEXEC);
580 if (signal_fd == -1) {
581 PLOG(FATAL) << "failed to create signalfd";
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700582 }
583
Ryan Prichard1325ec82018-04-11 18:46:38 -0700584 register_epoll_handler(signal_fd, HandleSignalFd);
Luis Hector Chavez9f97f472017-09-06 13:43:57 -0700585}
586
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800587int main(int argc, char** argv) {
Elliott Hughesda40c002015-03-27 23:20:44 -0700588 if (!strcmp(basename(argv[0]), "ueventd")) {
Colin Crossf83d0b92010-04-21 12:04:20 -0700589 return ueventd_main(argc, argv);
Elliott Hughesda40c002015-03-27 23:20:44 -0700590 }
Colin Crossf83d0b92010-04-21 12:04:20 -0700591
Elliott Hughesda40c002015-03-27 23:20:44 -0700592 if (!strcmp(basename(argv[0]), "watchdogd")) {
Arve Hjønnevågd97d9072012-06-13 21:51:56 -0700593 return watchdogd_main(argc, argv);
Elliott Hughesda40c002015-03-27 23:20:44 -0700594 }
Arve Hjønnevågd97d9072012-06-13 21:51:56 -0700595
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700596 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 Cherry663fdfc2017-03-10 14:46:38 -0800602 if (REBOOT_BOOTLOADER_ON_PANIC) {
Tom Cherry1ca83242017-08-25 15:10:48 -0700603 InstallRebootSignalHandlers();
Tom Cherry663fdfc2017-03-10 14:46:38 -0800604 }
605
Elliott Hughes9605a942016-11-10 17:43:47 -0800606 bool is_first_stage = (getenv("INIT_SECOND_STAGE") == nullptr);
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700607
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700608 if (is_first_stage) {
Tom Cherry34e70412017-03-16 18:08:56 -0700609 boot_clock::time_point start_time = boot_clock::now();
610
611 // Clear the umask.
612 umask(0);
613
Tom Cherry6de21f12017-08-22 15:41:03 -0700614 clearenv();
615 setenv("PATH", _PATH_DEFPATH, 1);
Tom Cherry34e70412017-03-16 18:08:56 -0700616 // 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 Kralevichf667a322015-04-25 17:42:52 -0700618 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 Kralevichc39ba5a2015-11-07 16:52:17 -0800622 #define MAKE_STR(x) __STRING(x)
623 mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
Tom Cherry34e70412017-03-16 18:08:56 -0700624 // Don't expose the raw commandline to unprivileged processes.
625 chmod("/proc/cmdline", 0440);
Nick Kralevich80960d22016-10-29 12:20:00 -0700626 gid_t groups[] = { AID_READPROC };
627 setgroups(arraysize(groups), groups);
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700628 mount("sysfs", "/sys", "sysfs", 0, NULL);
Nick Kralevich3d9e2732016-03-03 10:40:12 -0800629 mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
Josh Gaobf2dd482017-03-28 13:07:15 -0700630
Elliott Hughes35f5d042016-07-26 09:32:33 -0700631 mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
Josh Gaobf2dd482017-03-28 13:07:15 -0700632
633 if constexpr (WORLD_WRITABLE_KMSG) {
Tom Cherry1f87cd12017-08-11 13:22:37 -0700634 mknod("/dev/kmsg_debug", S_IFCHR | 0622, makedev(1, 11));
Josh Gaobf2dd482017-03-28 13:07:15 -0700635 }
636
Evgenii Stepanov102daa32016-11-18 14:58:40 -0800637 mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
638 mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700639
Tri Vo0b669692018-04-10 20:20:13 -0700640 // 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 Cherry34e70412017-03-16 18:08:56 -0700648 // 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 Hughesda40c002015-03-27 23:20:44 -0700651
Tom Cherry34e70412017-03-16 18:08:56 -0700652 LOG(INFO) << "init first stage started!";
Elliott Hughesda40c002015-03-27 23:20:44 -0700653
Bowgo Tsaid2620172017-04-17 22:17:09 +0800654 if (!DoFirstStageMount()) {
Tom Cherryd8db7ab2017-08-17 17:28:30 -0700655 LOG(FATAL) << "Failed to mount required partitions early ...";
Sandeep Patil35403eb2017-02-08 20:27:12 -0800656 }
Wei Wang313b3522016-10-28 12:22:32 -0700657
Bowgo Tsaifd18a452017-04-24 18:36:25 +0800658 SetInitAvbVersionInRecovery();
659
Steve Muckleaf1a9bf2017-07-17 15:14:02 -0700660 // Enable seccomp if global boot option was passed (otherwise it is enabled in zygote).
661 global_seccomp();
662
Elliott Hughes9605a942016-11-10 17:43:47 -0800663 // Set up SELinux, loading the SELinux policy.
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700664 SelinuxSetupKernelLogging();
665 SelinuxInitialize();
Wei Wang313b3522016-10-28 12:22:32 -0700666
Elliott Hughes9605a942016-11-10 17:43:47 -0800667 // We're in the kernel domain, so re-exec init to transition to the init domain now
Wei Wang313b3522016-10-28 12:22:32 -0700668 // that the SELinux policy has been loaded.
Tom Cherry482f36c2017-05-08 13:38:15 -0700669 if (selinux_android_restorecon("/init", 0) == -1) {
Tom Cherryd8db7ab2017-08-17 17:28:30 -0700670 PLOG(FATAL) << "restorecon failed of /init failed";
Wei Wang313b3522016-10-28 12:22:32 -0700671 }
Elliott Hughes9605a942016-11-10 17:43:47 -0800672
673 setenv("INIT_SECOND_STAGE", "true", 1);
674
James Hawkins27c05222017-01-26 11:55:44 -0800675 static constexpr uint32_t kNanosecondsPerMillisecond = 1e6;
676 uint64_t start_ms = start_time.time_since_epoch().count() / kNanosecondsPerMillisecond;
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700677 setenv("INIT_STARTED_AT", std::to_string(start_ms).c_str(), 1);
Elliott Hughes9605a942016-11-10 17:43:47 -0800678
Wei Wang313b3522016-10-28 12:22:32 -0700679 char* path = argv[0];
Elliott Hughes9605a942016-11-10 17:43:47 -0800680 char* args[] = { path, nullptr };
Tom Cherry34e70412017-03-16 18:08:56 -0700681 execv(path, args);
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700682
Tom Cherry34e70412017-03-16 18:08:56 -0700683 // execv() only returns if an error happened, in which case we
684 // panic and never fall through this conditional.
Tom Cherryd8db7ab2017-08-17 17:28:30 -0700685 PLOG(FATAL) << "execv(\"" << path << "\") failed";
Elliott Hughesf65730e2015-04-24 18:38:17 +0000686 }
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800687
Tom Cherry34e70412017-03-16 18:08:56 -0700688 // At this point we're in the second stage of init.
689 InitKernelLogging(argv);
690 LOG(INFO) << "init second stage started!";
691
Mark Salyzyn45996272017-05-02 14:44:39 -0700692 // 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 Hughesf8627ce2017-05-09 17:09:06 -0700695 keyctl_get_keyring_ID(KEY_SPEC_SESSION_KEYRING, 1);
Mark Salyzyn45996272017-05-02 14:44:39 -0700696
Tom Cherry34e70412017-03-16 18:08:56 -0700697 // 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 Tsai1a898c22017-04-13 21:17:48 +0800716 const char* avb_version = getenv("INIT_AVB_VERSION");
717 if (avb_version) property_set("ro.boot.avb_version", avb_version);
Tom Cherry34e70412017-03-16 18:08:56 -0700718
719 // Clean up our environment.
720 unsetenv("INIT_SECOND_STAGE");
721 unsetenv("INIT_STARTED_AT");
722 unsetenv("INIT_SELINUX_TOOK");
Bowgo Tsai1a898c22017-04-13 21:17:48 +0800723 unsetenv("INIT_AVB_VERSION");
Tom Cherry34e70412017-03-16 18:08:56 -0700724
725 // Now set up SELinux for second stage.
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700726 SelinuxSetupKernelLogging();
727 SelabelInitialize();
728 SelinuxRestoreContext();
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500729
Elliott Hughes929f4072015-04-24 21:13:44 -0700730 epoll_fd = epoll_create1(EPOLL_CLOEXEC);
731 if (epoll_fd == -1) {
Tom Cherry4a679452017-09-26 16:30:03 -0700732 PLOG(FATAL) << "epoll_create1 failed";
Elliott Hughes929f4072015-04-24 21:13:44 -0700733 }
734
Ryan Prichard1325ec82018-04-11 18:46:38 -0700735 InstallSignalFdHandler();
Elliott Hughes9042cae2015-04-24 17:43:21 -0700736
Riley Andrewse4b7b292014-06-16 15:06:21 -0700737 property_load_boot_defaults();
Sami Tolvanen9e9efca2015-12-07 12:33:58 +0000738 export_oem_lock_status();
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700739 start_property_service();
Amit Pundird2e74db2016-06-29 19:00:00 +0530740 set_usb_controller();
Dima Zavind7634c92011-12-16 14:18:06 -0800741
Tom Cherryb7349902015-08-26 11:43:36 -0700742 const BuiltinFunctionMap function_map;
743 Action::set_function_map(&function_map);
744
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700745 subcontexts = InitializeSubcontexts();
746
Tom Cherry30a6f272017-04-19 15:31:58 -0700747 ActionManager& am = ActionManager::GetInstance();
Tom Cherry911b9b12017-07-27 16:20:58 -0700748 ServiceList& sm = ServiceList::GetInstance();
Tom Cherry30a6f272017-04-19 15:31:58 -0700749
Tom Cherry67dee622017-07-27 12:54:48 -0700750 LoadBootScripts(am, sm);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700751
Tom Cherryd8a72572017-03-13 12:24:49 -0700752 // 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 Cherry30a6f272017-04-19 15:31:58 -0700754 if (false) DumpState();
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700755
756 am.QueueEventTrigger("early-init");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700757
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700758 // Queue an action that waits for coldboot done so we know ueventd has set up all of /dev...
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700759 am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700760 // ... so that we can start queuing up actions that require stuff from /dev.
Tom Cherry0c8d6d22017-08-10 12:22:44 -0700761 am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");
762 am.QueueBuiltinAction(SetMmapRndBitsAction, "SetMmapRndBits");
763 am.QueueBuiltinAction(SetKptrRestrictAction, "SetKptrRestrict");
Mark Salyzyn353bf1f2018-04-30 07:33:31 -0700764 am.QueueBuiltinAction(KeychordInitAction, "KeychordInit");
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700765 am.QueueBuiltinAction(console_init_action, "console_init");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700766
Elliott Hughesda40c002015-03-27 23:20:44 -0700767 // Trigger all the boot actions to get us started.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700768 am.QueueEventTrigger("init");
Dima Zavinca47cef2011-08-24 15:28:23 -0700769
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800770 // 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 Cherry0c8d6d22017-08-10 12:22:44 -0700772 am.QueueBuiltinAction(MixHwrngIntoLinuxRngAction, "MixHwrngIntoLinuxRng");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700773
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800774 // Don't mount filesystems or start core system services in charger mode.
Tom Cherryccf23532017-03-28 16:40:41 -0700775 std::string bootmode = GetProperty("ro.bootmode", "");
Yabin Cui74edcea2015-07-24 10:11:05 -0700776 if (bootmode == "charger") {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700777 am.QueueEventTrigger("charger");
Dima Zavinca47cef2011-08-24 15:28:23 -0700778 } else {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700779 am.QueueEventTrigger("late-init");
Dima Zavinca47cef2011-08-24 15:28:23 -0700780 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700781
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800782 // Run all property triggers based on current state of the properties.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700783 am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700784
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700785 while (true) {
Elliott Hughes9605a942016-11-10 17:43:47 -0800786 // By default, sleep until something happens.
787 int epoll_timeout_ms = -1;
788
Tom Cherry3633a402017-09-13 14:39:45 -0700789 if (do_shutdown && !shutting_down) {
790 do_shutdown = false;
791 if (HandlePowerctlMessage(shutdown_command)) {
792 shutting_down = true;
793 }
794 }
795
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700796 if (!(waiting_for_prop || Service::is_exec_service_running())) {
Tom Cherry77ddcd52017-03-23 16:54:38 -0700797 am.ExecuteOneCommand();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700798 }
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700799 if (!(waiting_for_prop || Service::is_exec_service_running())) {
Tom Cherryd269e3a2017-07-31 13:23:18 -0700800 if (!shutting_down) {
801 auto next_process_restart_time = RestartProcesses();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700802
Tom Cherryd269e3a2017-07-31 13:23:18 -0700803 // 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 Cherry77ddcd52017-03-23 16:54:38 -0700810 }
811
812 // If there's more work to do, wake up again immediately.
813 if (am.HasMoreCommands()) epoll_timeout_ms = 0;
814 }
Wei Wang16db4342016-11-30 15:43:42 -0800815
Elliott Hughes929f4072015-04-24 21:13:44 -0700816 epoll_event ev;
Elliott Hughes9605a942016-11-10 17:43:47 -0800817 int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, epoll_timeout_ms));
Elliott Hughes929f4072015-04-24 21:13:44 -0700818 if (nr == -1) {
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700819 PLOG(ERROR) << "epoll_wait failed";
Elliott Hughes929f4072015-04-24 21:13:44 -0700820 } else if (nr == 1) {
Tom Cherry8ae73752018-05-01 13:39:52 -0700821 std::invoke(*reinterpret_cast<std::function<void()>*>(ev.data.ptr));
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700822 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700823 }
824
825 return 0;
826}
Tom Cherry81f5d3e2017-06-22 12:53:17 -0700827
828} // namespace init
829} // namespace android