blob: ee1351d957509c15d7f744b9fddfda7c023d1e75 [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
Elliott Hughes8d82ea02015-02-06 20:15:18 -080017#include <ctype.h>
Rom Lemarchand6a524432015-02-28 06:39:11 -080018#include <dirent.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080019#include <errno.h>
20#include <fcntl.h>
21#include <libgen.h>
Elliott Hughescc86fb22015-03-17 20:01:13 -070022#include <paths.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080023#include <signal.h>
24#include <stdarg.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070025#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
Elliott Hughes929f4072015-04-24 21:13:44 -070028#include <sys/epoll.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070029#include <sys/mount.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070030#include <sys/socket.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080031#include <sys/stat.h>
32#include <sys/types.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070033#include <sys/un.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080034#include <sys/wait.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080035#include <unistd.h>
36
37#include <mtd/mtd-user.h>
Stephen Smalleye46f9d52012-01-13 08:48:47 -050038
Stephen Smalleye46f9d52012-01-13 08:48:47 -050039#include <selinux/selinux.h>
40#include <selinux/label.h>
Stephen Smalleyae6f3d72012-05-01 15:02:53 -040041#include <selinux/android.h>
Stephen Smalleye46f9d52012-01-13 08:48:47 -050042
Rom Lemarchand6a524432015-02-28 06:39:11 -080043#include <base/file.h>
44#include <base/stringprintf.h>
Elliott Hughese5ce30f2015-05-06 19:19:24 -070045#include <base/strings.h>
Nick Kralevich56fa0ac2013-06-24 17:41:40 -070046#include <cutils/android_reboot.h>
Alex Klyubin0d872d82013-08-16 13:19:24 -070047#include <cutils/fs.h>
Elliott Hughes8d82ea02015-02-06 20:15:18 -080048#include <cutils/iosched_policy.h>
49#include <cutils/list.h>
50#include <cutils/sockets.h>
Colin Crossf83d0b92010-04-21 12:04:20 -070051#include <private/android_filesystem_config.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070052
Rom Lemarchand6a524432015-02-28 06:39:11 -080053#include <memory>
54
Tom Cherryfa0c21c2015-07-23 17:53:11 -070055#include "action.h"
Tom Cherrybac32992015-07-31 12:45:25 -070056#include "bootchart.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070057#include "devices.h"
Tom Cherryb7349902015-08-26 11:43:36 -070058#include "import_parser.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070059#include "init.h"
Tom Cherrybac32992015-07-31 12:45:25 -070060#include "init_parser.h"
61#include "keychords.h"
Colin Crossed8a7d82010-04-19 17:05:34 -070062#include "log.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070063#include "property_service.h"
Tom Cherrybac32992015-07-31 12:45:25 -070064#include "service.h"
Colin Cross9c5366b2010-04-13 19:48:59 -070065#include "signal_handler.h"
Colin Crossf83d0b92010-04-21 12:04:20 -070066#include "ueventd.h"
Tom Cherrybac32992015-07-31 12:45:25 -070067#include "util.h"
Arve Hjønnevågd97d9072012-06-13 21:51:56 -070068#include "watchdogd.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070069
Stephen Smalleye46f9d52012-01-13 08:48:47 -050070struct selabel_handle *sehandle;
rpcraig63207cd2012-08-09 10:05:49 -040071struct selabel_handle *sehandle_prop;
Stephen Smalleye46f9d52012-01-13 08:48:47 -050072
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070073static int property_triggers_enabled = 0;
74
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070075static char qemu[32];
76
Tom Cherrybac32992015-07-31 12:45:25 -070077int have_console;
78std::string console_name = "/dev/console";
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070079static time_t process_needs_restart;
80
Tom Cherrybac32992015-07-31 12:45:25 -070081const char *ENV[32];
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070082
Elliott Hughes8d82ea02015-02-06 20:15:18 -080083bool waiting_for_exec = false;
84
Elliott Hughes929f4072015-04-24 21:13:44 -070085static int epoll_fd = -1;
86
87void register_epoll_handler(int fd, void (*fn)()) {
88 epoll_event ev;
89 ev.events = EPOLLIN;
90 ev.data.ptr = reinterpret_cast<void*>(fn);
91 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
92 ERROR("epoll_ctl failed: %s\n", strerror(errno));
93 }
94}
95
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070096/* add_environment - add "key=value" to the current environment */
97int add_environment(const char *key, const char *val)
98{
James Morrissey381341f2014-05-16 11:36:36 +010099 size_t n;
100 size_t key_len = strlen(key);
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700101
James Morrissey381341f2014-05-16 11:36:36 +0100102 /* The last environment entry is reserved to terminate the list */
103 for (n = 0; n < (ARRAY_SIZE(ENV) - 1); n++) {
104
105 /* Delete any existing entry for this key */
106 if (ENV[n] != NULL) {
107 size_t entry_key_len = strcspn(ENV[n], "=");
108 if ((entry_key_len == key_len) && (strncmp(ENV[n], key, entry_key_len) == 0)) {
109 free((char*)ENV[n]);
110 ENV[n] = NULL;
111 }
112 }
113
114 /* Add entry if a free slot is available */
115 if (ENV[n] == NULL) {
Elliott Hughesf3cf4382015-02-03 17:12:07 -0800116 char* entry;
117 asprintf(&entry, "%s=%s", key, val);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700118 ENV[n] = entry;
119 return 0;
120 }
121 }
122
James Morrissey381341f2014-05-16 11:36:36 +0100123 ERROR("No env. room to store: '%s':'%s'\n", key, val);
124
125 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700126}
127
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700128void property_changed(const char *name, const char *value)
129{
Colin Crossebc6ff12010-04-13 19:52:01 -0700130 if (property_triggers_enabled)
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700131 ActionManager::GetInstance().QueuePropertyTrigger(name, value);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700132}
133
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700134static void restart_processes()
135{
136 process_needs_restart = 0;
Tom Cherrybac32992015-07-31 12:45:25 -0700137 ServiceManager::GetInstance().
138 ForEachServiceWithFlags(SVC_RESTARTING, [] (Service* s) {
139 s->RestartIfNeeded(process_needs_restart);
140 });
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700141}
142
Tom Cherrybac32992015-07-31 12:45:25 -0700143static void msg_start(const std::string& name)
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700144{
Tom Cherrybac32992015-07-31 12:45:25 -0700145 Service* svc = nullptr;
146 std::vector<std::string> vargs;
San Mehatf24e2522009-05-19 13:30:46 -0700147
Tom Cherrybac32992015-07-31 12:45:25 -0700148 size_t colon_pos = name.find(':');
149 if (colon_pos == std::string::npos) {
150 svc = ServiceManager::GetInstance().FindServiceByName(name);
151 } else {
152 std::string service_name(name.substr(0, colon_pos));
153 std::string args(name.substr(colon_pos + 1));
154 vargs = android::base::Split(args, " ");
San Mehatf24e2522009-05-19 13:30:46 -0700155
Tom Cherrybac32992015-07-31 12:45:25 -0700156 svc = ServiceManager::GetInstance().FindServiceByName(service_name);
San Mehatf24e2522009-05-19 13:30:46 -0700157 }
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700158
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700159 if (svc) {
Tom Cherrybac32992015-07-31 12:45:25 -0700160 svc->Start(vargs);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700161 } else {
Tom Cherrybac32992015-07-31 12:45:25 -0700162 ERROR("no such service '%s'\n", name.c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700163 }
164}
165
Tom Cherrybac32992015-07-31 12:45:25 -0700166static void msg_stop(const std::string& name)
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700167{
Tom Cherrybac32992015-07-31 12:45:25 -0700168 Service* svc = ServiceManager::GetInstance().FindServiceByName(name);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700169
170 if (svc) {
Tom Cherrybac32992015-07-31 12:45:25 -0700171 svc->Stop();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700172 } else {
Tom Cherrybac32992015-07-31 12:45:25 -0700173 ERROR("no such service '%s'\n", name.c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700174 }
175}
176
Tom Cherrybac32992015-07-31 12:45:25 -0700177static void msg_restart(const std::string& name)
Mike Kasickb54f39f2012-01-25 23:48:46 -0500178{
Tom Cherrybac32992015-07-31 12:45:25 -0700179 Service* svc = ServiceManager::GetInstance().FindServiceByName(name);
Mike Kasickb54f39f2012-01-25 23:48:46 -0500180
181 if (svc) {
Tom Cherrybac32992015-07-31 12:45:25 -0700182 svc->Restart();
Mike Kasickb54f39f2012-01-25 23:48:46 -0500183 } else {
Tom Cherrybac32992015-07-31 12:45:25 -0700184 ERROR("no such service '%s'\n", name.c_str());
Mike Kasickb54f39f2012-01-25 23:48:46 -0500185 }
186}
187
Tom Cherrybac32992015-07-31 12:45:25 -0700188void handle_control_message(const std::string& msg, const std::string& arg)
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700189{
Tom Cherrybac32992015-07-31 12:45:25 -0700190 if (msg == "start") {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700191 msg_start(arg);
Tom Cherrybac32992015-07-31 12:45:25 -0700192 } else if (msg == "stop") {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700193 msg_stop(arg);
Tom Cherrybac32992015-07-31 12:45:25 -0700194 } else if (msg == "restart") {
Mike Kasickb54f39f2012-01-25 23:48:46 -0500195 msg_restart(arg);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700196 } else {
Tom Cherrybac32992015-07-31 12:45:25 -0700197 ERROR("unknown control msg '%s'\n", msg.c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700198 }
199}
200
Tom Cherry96f67312015-07-30 13:52:55 -0700201static int wait_for_coldboot_done_action(const std::vector<std::string>& args) {
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700202 Timer t;
203
204 NOTICE("Waiting for %s...\n", COLDBOOT_DONE);
Elliott Hughesc7331d02015-05-14 12:03:14 -0700205 // Any longer than 1s is an unreasonable length of time to delay booting.
206 // If you're hitting this timeout, check that you didn't make your
207 // sepolicy regular expressions too expensive (http://b/19899875).
208 if (wait_for_file(COLDBOOT_DONE, 1)) {
Andreas Gampea016c422014-11-24 19:52:41 -0800209 ERROR("Timed out waiting for %s\n", COLDBOOT_DONE);
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700210 }
211
212 NOTICE("Waiting for %s took %.2fs.\n", COLDBOOT_DONE, t.duration());
213 return 0;
Colin Crossebc6ff12010-04-13 19:52:01 -0700214}
215
Alex Klyubin0d872d82013-08-16 13:19:24 -0700216/*
217 * Writes 512 bytes of output from Hardware RNG (/dev/hw_random, backed
218 * by Linux kernel's hw_random framework) into Linux RNG's via /dev/urandom.
219 * Does nothing if Hardware RNG is not present.
220 *
221 * Since we don't yet trust the quality of Hardware RNG, these bytes are not
222 * mixed into the primary pool of Linux RNG and the entropy estimate is left
223 * unmodified.
224 *
225 * If the HW RNG device /dev/hw_random is present, we require that at least
226 * 512 bytes read from it are written into Linux RNG. QA is expected to catch
227 * devices/configurations where these I/O operations are blocking for a long
228 * time. We do not reboot or halt on failures, as this is a best-effort
229 * attempt.
230 */
Tom Cherry96f67312015-07-30 13:52:55 -0700231static int mix_hwrng_into_linux_rng_action(const std::vector<std::string>& args)
Alex Klyubin0d872d82013-08-16 13:19:24 -0700232{
233 int result = -1;
234 int hwrandom_fd = -1;
235 int urandom_fd = -1;
236 char buf[512];
237 ssize_t chunk_size;
238 size_t total_bytes_written = 0;
239
240 hwrandom_fd = TEMP_FAILURE_RETRY(
Nick Kralevich45a884f2015-02-02 14:37:22 -0800241 open("/dev/hw_random", O_RDONLY | O_NOFOLLOW | O_CLOEXEC));
Alex Klyubin0d872d82013-08-16 13:19:24 -0700242 if (hwrandom_fd == -1) {
243 if (errno == ENOENT) {
244 ERROR("/dev/hw_random not found\n");
245 /* It's not an error to not have a Hardware RNG. */
246 result = 0;
247 } else {
248 ERROR("Failed to open /dev/hw_random: %s\n", strerror(errno));
249 }
250 goto ret;
251 }
252
253 urandom_fd = TEMP_FAILURE_RETRY(
Nick Kralevich45a884f2015-02-02 14:37:22 -0800254 open("/dev/urandom", O_WRONLY | O_NOFOLLOW | O_CLOEXEC));
Alex Klyubin0d872d82013-08-16 13:19:24 -0700255 if (urandom_fd == -1) {
256 ERROR("Failed to open /dev/urandom: %s\n", strerror(errno));
257 goto ret;
258 }
259
260 while (total_bytes_written < sizeof(buf)) {
261 chunk_size = TEMP_FAILURE_RETRY(
262 read(hwrandom_fd, buf, sizeof(buf) - total_bytes_written));
263 if (chunk_size == -1) {
264 ERROR("Failed to read from /dev/hw_random: %s\n", strerror(errno));
265 goto ret;
266 } else if (chunk_size == 0) {
267 ERROR("Failed to read from /dev/hw_random: EOF\n");
268 goto ret;
269 }
270
271 chunk_size = TEMP_FAILURE_RETRY(write(urandom_fd, buf, chunk_size));
272 if (chunk_size == -1) {
273 ERROR("Failed to write to /dev/urandom: %s\n", strerror(errno));
274 goto ret;
275 }
276 total_bytes_written += chunk_size;
277 }
278
Elliott Hughesccecf142014-01-16 10:53:11 -0800279 INFO("Mixed %zu bytes from /dev/hw_random into /dev/urandom",
Alex Klyubin0d872d82013-08-16 13:19:24 -0700280 total_bytes_written);
281 result = 0;
282
283ret:
284 if (hwrandom_fd != -1) {
285 close(hwrandom_fd);
286 }
287 if (urandom_fd != -1) {
288 close(urandom_fd);
289 }
Alex Klyubin0d872d82013-08-16 13:19:24 -0700290 return result;
291}
292
Tom Cherry96f67312015-07-30 13:52:55 -0700293static int keychord_init_action(const std::vector<std::string>& args)
Colin Crossebc6ff12010-04-13 19:52:01 -0700294{
295 keychord_init();
296 return 0;
297}
298
Tom Cherry96f67312015-07-30 13:52:55 -0700299static int console_init_action(const std::vector<std::string>& args)
Colin Crossebc6ff12010-04-13 19:52:01 -0700300{
Yabin Cui74edcea2015-07-24 10:11:05 -0700301 std::string console = property_get("ro.boot.console");
302 if (!console.empty()) {
303 console_name = "/dev/" + console;
Colin Crossebc6ff12010-04-13 19:52:01 -0700304 }
305
Yabin Cui74edcea2015-07-24 10:11:05 -0700306 int fd = open(console_name.c_str(), O_RDWR | O_CLOEXEC);
Colin Crossebc6ff12010-04-13 19:52:01 -0700307 if (fd >= 0)
308 have_console = 1;
309 close(fd);
310
Nick Kralevich45a884f2015-02-02 14:37:22 -0800311 fd = open("/dev/tty0", O_WRONLY | O_CLOEXEC);
Marcin Chojnacki50dc9362013-10-16 17:39:16 +0200312 if (fd >= 0) {
313 const char *msg;
314 msg = "\n"
315 "\n"
316 "\n"
317 "\n"
318 "\n"
319 "\n"
320 "\n" // console is 40 cols x 30 lines
321 "\n"
322 "\n"
323 "\n"
324 "\n"
325 "\n"
326 "\n"
327 "\n"
328 " A N D R O I D ";
329 write(fd, msg, strlen(msg));
330 close(fd);
Colin Crossebc6ff12010-04-13 19:52:01 -0700331 }
Marcin Chojnacki50dc9362013-10-16 17:39:16 +0200332
Colin Crossebc6ff12010-04-13 19:52:01 -0700333 return 0;
334}
335
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700336static void import_kernel_nv(const std::string& key, const std::string& value, bool for_emulator) {
337 if (key.empty()) return;
Dima Zavin5511c842011-12-19 11:21:32 -0800338
339 if (for_emulator) {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700340 // In the emulator, export any kernel option with the "ro.kernel." prefix.
341 property_set(android::base::StringPrintf("ro.kernel.%s", key.c_str()).c_str(), value.c_str());
Dima Zavin5511c842011-12-19 11:21:32 -0800342 return;
343 }
344
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700345 if (key == "qemu") {
346 strlcpy(qemu, value.c_str(), sizeof(qemu));
347 } else if (android::base::StartsWith(key, "androidboot.")) {
348 property_set(android::base::StringPrintf("ro.boot.%s", key.c_str() + 12).c_str(),
349 value.c_str());
Dima Zavin5511c842011-12-19 11:21:32 -0800350 }
351}
352
Elliott Hughesd679bc92015-03-20 08:50:46 -0700353static void export_kernel_boot_props() {
Dima Zavin5511c842011-12-19 11:21:32 -0800354 struct {
355 const char *src_prop;
Elliott Hughesd679bc92015-03-20 08:50:46 -0700356 const char *dst_prop;
357 const char *default_value;
Dima Zavin5511c842011-12-19 11:21:32 -0800358 } prop_map[] = {
Elliott Hughesd679bc92015-03-20 08:50:46 -0700359 { "ro.boot.serialno", "ro.serialno", "", },
360 { "ro.boot.mode", "ro.bootmode", "unknown", },
361 { "ro.boot.baseband", "ro.baseband", "unknown", },
Dima Zavin5511c842011-12-19 11:21:32 -0800362 { "ro.boot.bootloader", "ro.bootloader", "unknown", },
Elliott Hughesd679bc92015-03-20 08:50:46 -0700363 { "ro.boot.hardware", "ro.hardware", "unknown", },
364 { "ro.boot.revision", "ro.revision", "0", },
Dima Zavin5511c842011-12-19 11:21:32 -0800365 };
Elliott Hughesd679bc92015-03-20 08:50:46 -0700366 for (size_t i = 0; i < ARRAY_SIZE(prop_map); i++) {
Yabin Cui74edcea2015-07-24 10:11:05 -0700367 std::string value = property_get(prop_map[i].src_prop);
368 property_set(prop_map[i].dst_prop, (!value.empty()) ? value.c_str() : prop_map[i].default_value);
Dima Zavin5511c842011-12-19 11:21:32 -0800369 }
Dima Zavin5511c842011-12-19 11:21:32 -0800370}
Colin Crossebc6ff12010-04-13 19:52:01 -0700371
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700372static void process_kernel_dt() {
Rom Lemarchand6a524432015-02-28 06:39:11 -0800373 static const char android_dir[] = "/proc/device-tree/firmware/android";
374
375 std::string file_name = android::base::StringPrintf("%s/compatible", android_dir);
376
377 std::string dt_file;
378 android::base::ReadFileToString(file_name, &dt_file);
379 if (!dt_file.compare("android,firmware")) {
380 ERROR("firmware/android is not compatible with 'android,firmware'\n");
381 return;
382 }
383
384 std::unique_ptr<DIR, int(*)(DIR*)>dir(opendir(android_dir), closedir);
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700385 if (!dir) return;
Rom Lemarchand6a524432015-02-28 06:39:11 -0800386
387 struct dirent *dp;
388 while ((dp = readdir(dir.get())) != NULL) {
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700389 if (dp->d_type != DT_REG || !strcmp(dp->d_name, "compatible")) {
Rom Lemarchand6a524432015-02-28 06:39:11 -0800390 continue;
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700391 }
Rom Lemarchand6a524432015-02-28 06:39:11 -0800392
393 file_name = android::base::StringPrintf("%s/%s", android_dir, dp->d_name);
394
395 android::base::ReadFileToString(file_name, &dt_file);
396 std::replace(dt_file.begin(), dt_file.end(), ',', '.');
397
398 std::string property_name = android::base::StringPrintf("ro.boot.%s", dp->d_name);
Elliott Hughesdb3f2672015-03-20 09:45:18 -0700399 property_set(property_name.c_str(), dt_file.c_str());
Rom Lemarchand6a524432015-02-28 06:39:11 -0800400 }
401}
402
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700403static void process_kernel_cmdline() {
404 // Don't expose the raw commandline to unprivileged processes.
Dima Zavin5511c842011-12-19 11:21:32 -0800405 chmod("/proc/cmdline", 0440);
Colin Crossebc6ff12010-04-13 19:52:01 -0700406
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700407 // The first pass does the common stuff, and finds if we are in qemu.
408 // The second pass is only necessary for qemu to export all kernel params
409 // as properties.
Nick Kralevichf667a322015-04-25 17:42:52 -0700410 import_kernel_cmdline(false, import_kernel_nv);
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700411 if (qemu[0]) import_kernel_cmdline(true, import_kernel_nv);
Colin Crossebc6ff12010-04-13 19:52:01 -0700412}
413
Tom Cherry96f67312015-07-30 13:52:55 -0700414static int queue_property_triggers_action(const std::vector<std::string>& args)
Colin Crossebc6ff12010-04-13 19:52:01 -0700415{
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700416 ActionManager::GetInstance().QueueAllPropertyTriggers();
Colin Crossebc6ff12010-04-13 19:52:01 -0700417 /* enable property triggers */
418 property_triggers_enabled = 1;
419 return 0;
420}
421
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700422static void selinux_init_all_handles(void)
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500423{
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400424 sehandle = selinux_android_file_context_handle();
Stephen Smalleydbd37f22014-01-28 10:34:09 -0500425 selinux_android_set_sehandle(sehandle);
rpcraig63207cd2012-08-09 10:05:49 -0400426 sehandle_prop = selinux_android_prop_context_handle();
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400427}
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500428
Nick Kralevichd34e4072015-04-28 12:39:41 -0700429enum selinux_enforcing_status { SELINUX_PERMISSIVE, SELINUX_ENFORCING };
Nick Kralevichf667a322015-04-25 17:42:52 -0700430
431static selinux_enforcing_status selinux_status_from_cmdline() {
432 selinux_enforcing_status status = SELINUX_ENFORCING;
433
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700434 import_kernel_cmdline(false, [&](const std::string& key, const std::string& value, bool in_qemu) {
435 if (key == "androidboot.selinux" && value == "permissive") {
436 status = SELINUX_PERMISSIVE;
Nick Kralevichf667a322015-04-25 17:42:52 -0700437 }
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700438 });
Nick Kralevichf667a322015-04-25 17:42:52 -0700439
440 return status;
441}
442
Nick Kralevich935bd3e2013-06-26 15:37:26 -0700443static bool selinux_is_enforcing(void)
444{
Nick Kralevichd34e4072015-04-28 12:39:41 -0700445 if (ALLOW_PERMISSIVE_SELINUX) {
Nick Kralevichf667a322015-04-25 17:42:52 -0700446 return selinux_status_from_cmdline() == SELINUX_ENFORCING;
Nick Kralevich935bd3e2013-06-26 15:37:26 -0700447 }
Nick Kralevich935bd3e2013-06-26 15:37:26 -0700448 return true;
449}
450
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400451int selinux_reload_policy(void)
452{
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400453 INFO("SELinux: Attempting to reload policy files\n");
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500454
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400455 if (selinux_android_reload_policy() == -1) {
456 return -1;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500457 }
458
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400459 if (sehandle)
460 selabel_close(sehandle);
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500461
rpcraig63207cd2012-08-09 10:05:49 -0400462 if (sehandle_prop)
463 selabel_close(sehandle_prop);
464
Stephen Smalleyae6f3d72012-05-01 15:02:53 -0400465 selinux_init_all_handles();
466 return 0;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500467}
rpcraig63207cd2012-08-09 10:05:49 -0400468
Elliott Hughesda40c002015-03-27 23:20:44 -0700469static int audit_callback(void *data, security_class_t /*cls*/, char *buf, size_t len) {
rpcraig63207cd2012-08-09 10:05:49 -0400470 snprintf(buf, len, "property=%s", !data ? "NULL" : (char *)data);
471 return 0;
472}
473
Elliott Hughesf65730e2015-04-24 18:38:17 +0000474static void security_failure() {
475 ERROR("Security failure; rebooting into recovery mode...\n");
476 android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
477 while (true) { pause(); } // never reached
478}
479
480static void selinux_initialize(bool in_kernel_domain) {
Elliott Hughesda40c002015-03-27 23:20:44 -0700481 Timer t;
Stephen Smalleyeb3f4212014-02-12 16:17:00 -0500482
Elliott Hughesda40c002015-03-27 23:20:44 -0700483 selinux_callback cb;
484 cb.func_log = selinux_klog_callback;
485 selinux_set_callback(SELINUX_CB_LOG, cb);
486 cb.func_audit = audit_callback;
487 selinux_set_callback(SELINUX_CB_AUDIT, cb);
488
Elliott Hughesf65730e2015-04-24 18:38:17 +0000489 if (in_kernel_domain) {
Elliott Hughesf65730e2015-04-24 18:38:17 +0000490 INFO("Loading SELinux policy...\n");
491 if (selinux_android_load_policy() < 0) {
492 ERROR("failed to load policy: %s\n", strerror(errno));
493 security_failure();
494 }
495
Nick Kralevichd34e4072015-04-28 12:39:41 -0700496 bool kernel_enforcing = (security_getenforce() == 1);
Elliott Hughesf65730e2015-04-24 18:38:17 +0000497 bool is_enforcing = selinux_is_enforcing();
Nick Kralevichd34e4072015-04-28 12:39:41 -0700498 if (kernel_enforcing != is_enforcing) {
499 if (security_setenforce(is_enforcing)) {
500 ERROR("security_setenforce(%s) failed: %s\n",
501 is_enforcing ? "true" : "false", strerror(errno));
502 security_failure();
503 }
504 }
Elliott Hughesf65730e2015-04-24 18:38:17 +0000505
Nick Kralevicheedbe812015-04-25 14:10:03 -0700506 if (write_file("/sys/fs/selinux/checkreqprot", "0") == -1) {
507 security_failure();
508 }
509
Elliott Hughesf65730e2015-04-24 18:38:17 +0000510 NOTICE("(Initializing SELinux %s took %.2fs.)\n",
511 is_enforcing ? "enforcing" : "non-enforcing", t.duration());
512 } else {
513 selinux_init_all_handles();
Nick Kralevich56fa0ac2013-06-24 17:41:40 -0700514 }
Nick Kralevich56fa0ac2013-06-24 17:41:40 -0700515}
516
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800517int main(int argc, char** argv) {
Elliott Hughesda40c002015-03-27 23:20:44 -0700518 if (!strcmp(basename(argv[0]), "ueventd")) {
Colin Crossf83d0b92010-04-21 12:04:20 -0700519 return ueventd_main(argc, argv);
Elliott Hughesda40c002015-03-27 23:20:44 -0700520 }
Colin Crossf83d0b92010-04-21 12:04:20 -0700521
Elliott Hughesda40c002015-03-27 23:20:44 -0700522 if (!strcmp(basename(argv[0]), "watchdogd")) {
Arve Hjønnevågd97d9072012-06-13 21:51:56 -0700523 return watchdogd_main(argc, argv);
Elliott Hughesda40c002015-03-27 23:20:44 -0700524 }
Arve Hjønnevågd97d9072012-06-13 21:51:56 -0700525
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800526 // Clear the umask.
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700527 umask(0);
528
Elliott Hughescc86fb22015-03-17 20:01:13 -0700529 add_environment("PATH", _PATH_DEFPATH);
530
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700531 bool is_first_stage = (argc == 1) || (strcmp(argv[1], "--second-stage") != 0);
532
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800533 // Get the basic filesystem setup we need put together in the initramdisk
534 // on / and then we'll let the rc file figure out the rest.
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700535 if (is_first_stage) {
Nick Kralevichf667a322015-04-25 17:42:52 -0700536 mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
537 mkdir("/dev/pts", 0755);
538 mkdir("/dev/socket", 0755);
539 mount("devpts", "/dev/pts", "devpts", 0, NULL);
Nick Kralevich9dec93b2015-04-25 15:50:03 -0700540 mount("proc", "/proc", "proc", 0, NULL);
541 mount("sysfs", "/sys", "sysfs", 0, NULL);
542 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700543
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800544 // We must have some place other than / to create the device nodes for
545 // kmsg and null, otherwise we won't be able to remount / read-only
546 // later on. Now that tmpfs is mounted on /dev, we can actually talk
547 // to the outside world.
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700548 open_devnull_stdio();
Dima Zavin8f912822011-08-31 18:26:17 -0700549 klog_init();
Elliott Hughesda40c002015-03-27 23:20:44 -0700550 klog_set_level(KLOG_NOTICE_LEVEL);
551
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700552 NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
Elliott Hughesda40c002015-03-27 23:20:44 -0700553
Nick Kralevichf667a322015-04-25 17:42:52 -0700554 if (!is_first_stage) {
555 // Indicate that booting is in progress to background fw loaders, etc.
556 close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
Vladimir Chtchetkine2b995432011-09-28 09:55:31 -0700557
Nick Kralevichf667a322015-04-25 17:42:52 -0700558 property_init();
Dima Zavin5511c842011-12-19 11:21:32 -0800559
Nick Kralevichf667a322015-04-25 17:42:52 -0700560 // If arguments are passed both on the command line and in DT,
561 // properties set in DT always have priority over the command-line ones.
562 process_kernel_dt();
563 process_kernel_cmdline();
564
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700565 // Propagate the kernel variables to internal variables
Nick Kralevichf667a322015-04-25 17:42:52 -0700566 // used by init as well as the current required properties.
567 export_kernel_boot_props();
568 }
Rom Lemarchand6a524432015-02-28 06:39:11 -0800569
Elliott Hughesf65730e2015-04-24 18:38:17 +0000570 // Set up SELinux, including loading the SELinux policy if we're in the kernel domain.
571 selinux_initialize(is_first_stage);
572
573 // If we're in the kernel domain, re-exec init to transition to the init domain now
574 // that the SELinux policy has been loaded.
575 if (is_first_stage) {
576 if (restorecon("/init") == -1) {
577 ERROR("restorecon failed: %s\n", strerror(errno));
578 security_failure();
579 }
580 char* path = argv[0];
581 char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };
582 if (execv(path, args) == -1) {
583 ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));
584 security_failure();
585 }
586 }
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800587
588 // These directories were necessarily created before initial policy load
589 // and therefore need their security context restored to the proper value.
590 // This must happen before /dev is populated by ueventd.
Elliott Hughese5ce30f2015-05-06 19:19:24 -0700591 NOTICE("Running restorecon...\n");
Stephen Smalleye096e362012-06-11 13:37:39 -0400592 restorecon("/dev");
593 restorecon("/dev/socket");
Geremy Condra8e15eab2013-02-28 17:29:58 -0800594 restorecon("/dev/__properties__");
Nick Kralevichae76f6d2013-07-11 15:38:26 -0700595 restorecon_recursive("/sys");
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500596
Elliott Hughes929f4072015-04-24 21:13:44 -0700597 epoll_fd = epoll_create1(EPOLL_CLOEXEC);
598 if (epoll_fd == -1) {
599 ERROR("epoll_create1 failed: %s\n", strerror(errno));
600 exit(1);
601 }
602
603 signal_handler_init();
Elliott Hughes9042cae2015-04-24 17:43:21 -0700604
Riley Andrewse4b7b292014-06-16 15:06:21 -0700605 property_load_boot_defaults();
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700606 start_property_service();
Dima Zavind7634c92011-12-16 14:18:06 -0800607
Tom Cherryb7349902015-08-26 11:43:36 -0700608 const BuiltinFunctionMap function_map;
609 Action::set_function_map(&function_map);
610
611 Parser& parser = Parser::GetInstance();
612 parser.AddSectionParser("service",std::make_unique<ServiceParser>());
613 parser.AddSectionParser("on", std::make_unique<ActionParser>());
614 parser.AddSectionParser("import", std::make_unique<ImportParser>());
615 parser.ParseConfig("/init.rc");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700616
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700617 ActionManager& am = ActionManager::GetInstance();
618
619 am.QueueEventTrigger("early-init");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700620
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700621 // 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 -0700622 am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700623 // ... so that we can start queuing up actions that require stuff from /dev.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700624 am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
625 am.QueueBuiltinAction(keychord_init_action, "keychord_init");
626 am.QueueBuiltinAction(console_init_action, "console_init");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700627
Elliott Hughesda40c002015-03-27 23:20:44 -0700628 // Trigger all the boot actions to get us started.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700629 am.QueueEventTrigger("init");
Dima Zavinca47cef2011-08-24 15:28:23 -0700630
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800631 // Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
632 // wasn't ready immediately after wait_for_coldboot_done
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700633 am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700634
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800635 // Don't mount filesystems or start core system services in charger mode.
Yabin Cui74edcea2015-07-24 10:11:05 -0700636 std::string bootmode = property_get("ro.bootmode");
637 if (bootmode == "charger") {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700638 am.QueueEventTrigger("charger");
Dima Zavinca47cef2011-08-24 15:28:23 -0700639 } else {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700640 am.QueueEventTrigger("late-init");
Dima Zavinca47cef2011-08-24 15:28:23 -0700641 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700642
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800643 // Run all property triggers based on current state of the properties.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700644 am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700645
Elliott Hughesc6c26ed2015-04-24 18:50:30 -0700646 while (true) {
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800647 if (!waiting_for_exec) {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700648 am.ExecuteOneCommand();
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800649 restart_processes();
650 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700651
Yongqin Liua197ff12014-12-05 13:45:02 +0800652 int timeout = -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700653 if (process_needs_restart) {
654 timeout = (process_needs_restart - gettime()) * 1000;
655 if (timeout < 0)
656 timeout = 0;
657 }
658
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700659 if (am.HasMoreCommands()) {
Colin Crossebc6ff12010-04-13 19:52:01 -0700660 timeout = 0;
Elliott Hughesc0e919c2015-02-04 14:46:36 -0800661 }
Colin Crossebc6ff12010-04-13 19:52:01 -0700662
Yongqin Liua197ff12014-12-05 13:45:02 +0800663 bootchart_sample(&timeout);
Elliott Hughesc0e919c2015-02-04 14:46:36 -0800664
Elliott Hughes929f4072015-04-24 21:13:44 -0700665 epoll_event ev;
666 int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
667 if (nr == -1) {
668 ERROR("epoll_wait failed: %s\n", strerror(errno));
669 } else if (nr == 1) {
670 ((void (*)()) ev.data.ptr)();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700671 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700672 }
673
674 return 0;
675}