blob: 25f324ce51cb6f5a6e750f96aefdc2b9ef9703cc [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 Cherryb7349902015-08-26 11:43:36 -070017#include "builtins.h"
18
Mark Salyzyna98cc9c2016-04-05 13:43:40 -070019#include <dirent.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070020#include <errno.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070021#include <fcntl.h>
Wei Wang542aae42017-08-04 13:22:36 -070022#include <fts.h>
Jiyong Parkc2404402018-11-08 17:14:35 +090023#include <glob.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070024#include <linux/loop.h>
25#include <linux/module.h>
Yusuke Sato0df08272015-07-08 14:57:07 -070026#include <mntent.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070027#include <net/if.h>
Mark Salyzynad575e02016-04-05 08:10:25 -070028#include <sched.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070029#include <signal.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070030#include <stdio.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070031#include <stdlib.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070032#include <string.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070033#include <sys/mount.h>
34#include <sys/resource.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070035#include <sys/socket.h>
36#include <sys/stat.h>
Nick Kralevich124a9c92016-03-27 16:55:59 -070037#include <sys/syscall.h>
Tom Cherryf57c0bf2017-04-07 13:46:21 -070038#include <sys/system_properties.h>
Elliott Hughes3d74d7a2015-01-29 21:31:23 -080039#include <sys/time.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070040#include <sys/types.h>
Ken Sumrall0e9dd902012-04-17 17:20:16 -070041#include <sys/wait.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070042#include <unistd.h>
Stephen Smalleye46f9d52012-01-13 08:48:47 -050043
Tom Cherryede0d532017-07-06 14:20:11 -070044#include <android-base/chrono_utils.h>
Mark Salyzyna98cc9c2016-04-05 13:43:40 -070045#include <android-base/file.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070046#include <android-base/logging.h>
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -080047#include <android-base/parseint.h>
Tom Cherryccf23532017-03-28 16:40:41 -070048#include <android-base/properties.h>
Tom Cherry70379912017-08-01 14:10:11 -070049#include <android-base/stringprintf.h>
Tom Cherryccf23532017-03-28 16:40:41 -070050#include <android-base/strings.h>
Tom Cherry70379912017-08-01 14:10:11 -070051#include <android-base/unique_fd.h>
Yabin Cui0b1252c2016-06-24 18:28:03 -070052#include <bootloader_message/bootloader_message.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070053#include <cutils/android_reboot.h>
Tom Cherryccf23532017-03-28 16:40:41 -070054#include <fs_mgr.h>
Eric Biggersf05da4a2018-10-23 13:10:33 -070055#include <fscrypt/fscrypt.h>
56#include <fscrypt/fscrypt_init_extensions.h>
David Anderson0e330f12019-01-03 18:16:56 -080057#include <libgsi/libgsi.h>
Tom Cherry3f5eaae52017-04-06 16:30:22 -070058#include <selinux/android.h>
59#include <selinux/label.h>
60#include <selinux/selinux.h>
Wei Wang02628f32017-08-16 11:34:50 -070061#include <system/thread_defs.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070062
Tom Cherry7fd3bc22018-02-13 15:36:14 -080063#include "action_manager.h"
Tom Cherryb7349902015-08-26 11:43:36 -070064#include "bootchart.h"
Tom Cherrybac32992015-07-31 12:45:25 -070065#include "init.h"
Jiyong Park68660412019-01-16 23:00:59 +090066#include "mount_namespace.h"
Tom Cherry67dee622017-07-27 12:54:48 -070067#include "parser.h"
Tom Cherrybac32992015-07-31 12:45:25 -070068#include "property_service.h"
Keun-young Park8d01f632017-03-13 11:54:47 -070069#include "reboot.h"
Tom Cherry7ac013d2017-08-25 10:39:25 -070070#include "rlimit_parser.h"
Joel Galenson4b591f12017-11-27 14:45:26 -080071#include "selinux.h"
Tom Cherrybac32992015-07-31 12:45:25 -070072#include "service.h"
Tom Cherrycb0f9bb2017-09-12 15:58:47 -070073#include "subcontext.h"
Tom Cherrybac32992015-07-31 12:45:25 -070074#include "util.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070075
Paul Crowley0b8b2302016-12-19 13:03:47 -080076using namespace std::literals::string_literals;
77
Tom Cherrycf80b6d2019-01-07 14:25:31 -080078using android::base::Basename;
Tom Cherry70379912017-08-01 14:10:11 -070079using android::base::unique_fd;
Tom Cherrya3530e62019-01-30 13:25:35 -080080using android::fs_mgr::Fstab;
81using android::fs_mgr::ReadFstabFromFile;
Tom Cherry70379912017-08-01 14:10:11 -070082
Nick Kralevichbc609542015-01-31 21:39:46 -080083#define chmod DO_NOT_USE_CHMOD_USE_FCHMODAT_SYMLINK_NOFOLLOW
84
Tom Cherry81f5d3e2017-06-22 12:53:17 -070085namespace android {
86namespace init {
87
Elliott Hughes9605a942016-11-10 17:43:47 -080088static constexpr std::chrono::nanoseconds kCommandRetryTimeout = 5s;
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -080089
Tom Cherry7fa62c52017-08-01 13:50:23 -070090static Result<Success> reboot_into_recovery(const std::vector<std::string>& options) {
Paul Crowleyc73b2152018-04-13 17:38:57 +000091 LOG(ERROR) << "Rebooting into recovery";
Paul Crowleyaf8be582016-05-10 08:52:06 -070092 std::string err;
93 if (!write_bootloader_message(options, &err)) {
Tom Cherry7fa62c52017-08-01 13:50:23 -070094 return Error() << "Failed to set bootloader message: " << err;
Paul Crowleyaf8be582016-05-10 08:52:06 -070095 }
Wei Wangeeab4912017-06-27 22:08:45 -070096 property_set("sys.powerctl", "reboot,recovery");
Tom Cherry7fa62c52017-08-01 13:50:23 -070097 return Success();
Yusuke Sato0df08272015-07-08 14:57:07 -070098}
99
Tom Cherry911b9b12017-07-27 16:20:58 -0700100template <typename F>
101static void ForEachServiceInClass(const std::string& classname, F function) {
102 for (const auto& service : ServiceList::GetInstance()) {
103 if (service->classnames().count(classname)) std::invoke(function, service);
104 }
105}
106
Martijn Coenenebce6752019-05-15 22:04:13 +0200107static Result<Success> do_class_start(const BuiltinArguments& args) {
Daniel Rosenbergca00b0e2018-11-27 22:08:02 -0800108 // Do not start a class if it has a property persist.dont_start_class.CLASS set to 1.
Martijn Coenenebce6752019-05-15 22:04:13 +0200109 if (android::base::GetBoolProperty("persist.init.dont_start_class." + args[1], false))
Daniel Rosenbergca00b0e2018-11-27 22:08:02 -0800110 return Success();
Tom Cherry911b9b12017-07-27 16:20:58 -0700111 // Starting a class does not start services which are explicitly disabled.
112 // They must be started individually.
Tom Cherry20acdef2017-10-03 13:15:03 -0700113 for (const auto& service : ServiceList::GetInstance()) {
Martijn Coenenebce6752019-05-15 22:04:13 +0200114 if (service->classnames().count(args[1])) {
Tom Cherry20acdef2017-10-03 13:15:03 -0700115 if (auto result = service->StartIfNotDisabled(); !result) {
116 LOG(ERROR) << "Could not start service '" << service->name()
Martijn Coenenebce6752019-05-15 22:04:13 +0200117 << "' as part of class '" << args[1] << "': " << result.error();
Tom Cherry20acdef2017-10-03 13:15:03 -0700118 }
119 }
120 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700121 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700122}
123
Martijn Coenenf0bc58a2019-04-23 16:26:01 +0200124static Result<Success> do_class_start_post_data(const BuiltinArguments& args) {
125 if (args.context != kInitContext) {
126 return Error() << "command 'class_start_post_data' only available in init context";
127 }
Martijn Coenenebce6752019-05-15 22:04:13 +0200128 for (const auto& service : ServiceList::GetInstance()) {
129 if (service->classnames().count(args[1])) {
130 if (auto result = service->StartIfPostData(); !result) {
131 LOG(ERROR) << "Could not start service '" << service->name()
132 << "' as part of class '" << args[1] << "': " << result.error();
133 }
134 }
135 }
136 return Success();
Martijn Coenenf0bc58a2019-04-23 16:26:01 +0200137}
138
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700139static Result<Success> do_class_stop(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700140 ForEachServiceInClass(args[1], &Service::Stop);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700141 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700142}
143
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700144static Result<Success> do_class_reset(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700145 ForEachServiceInClass(args[1], &Service::Reset);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700146 return Success();
Ken Sumrall752923c2010-12-03 16:33:31 -0800147}
148
Martijn Coenenf0bc58a2019-04-23 16:26:01 +0200149static Result<Success> do_class_reset_post_data(const BuiltinArguments& args) {
150 if (args.context != kInitContext) {
151 return Error() << "command 'class_reset_post_data' only available in init context";
152 }
153 ForEachServiceInClass(args[1], &Service::ResetIfPostData);
154 return Success();
155}
156
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700157static Result<Success> do_class_restart(const BuiltinArguments& args) {
Daniel Rosenbergca00b0e2018-11-27 22:08:02 -0800158 // Do not restart a class if it has a property persist.dont_start_class.CLASS set to 1.
159 if (android::base::GetBoolProperty("persist.init.dont_start_class." + args[1], false))
160 return Success();
Tom Cherry911b9b12017-07-27 16:20:58 -0700161 ForEachServiceInClass(args[1], &Service::Restart);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700162 return Success();
Steven Moreland2b63d542017-03-10 14:04:37 -0800163}
164
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700165static Result<Success> do_domainname(const BuiltinArguments& args) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700166 if (auto result = WriteFile("/proc/sys/kernel/domainname", args[1]); !result) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700167 return Error() << "Unable to write to /proc/sys/kernel/domainname: " << result.error();
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700168 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700169 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700170}
171
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700172static Result<Success> do_enable(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700173 Service* svc = ServiceList::GetInstance().FindService(args[1]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700174 if (!svc) return Error() << "Could not find service";
175
Tom Cherry76af7e62017-08-22 16:13:59 -0700176 if (auto result = svc->Enable(); !result) {
177 return Error() << "Could not enable service: " << result.error();
178 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700179
180 return Success();
JP Abgrall3beec7e2014-05-02 21:14:29 -0700181}
182
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700183static Result<Success> do_exec(const BuiltinArguments& args) {
184 auto service = Service::MakeTemporaryOneshotService(args.args);
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700185 if (!service) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700186 return Error() << "Could not create exec service";
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700187 }
Tom Cherry76af7e62017-08-22 16:13:59 -0700188 if (auto result = service->ExecStart(); !result) {
189 return Error() << "Could not start exec service: " << result.error();
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700190 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700191
Tom Cherry911b9b12017-07-27 16:20:58 -0700192 ServiceList::GetInstance().AddService(std::move(service));
Tom Cherry7fa62c52017-08-01 13:50:23 -0700193 return Success();
Tom Cherryb27004a2017-03-27 16:27:30 -0700194}
195
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700196static Result<Success> do_exec_background(const BuiltinArguments& args) {
197 auto service = Service::MakeTemporaryOneshotService(args.args);
Tom Cherry3631c542017-09-18 12:16:27 -0700198 if (!service) {
199 return Error() << "Could not create exec background service";
200 }
201 if (auto result = service->Start(); !result) {
202 return Error() << "Could not start exec background service: " << result.error();
203 }
204
205 ServiceList::GetInstance().AddService(std::move(service));
206 return Success();
207}
208
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700209static Result<Success> do_exec_start(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700210 Service* service = ServiceList::GetInstance().FindService(args[1]);
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700211 if (!service) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700212 return Error() << "Service not found";
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700213 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700214
Tom Cherry76af7e62017-08-22 16:13:59 -0700215 if (auto result = service->ExecStart(); !result) {
216 return Error() << "Could not start exec service: " << result.error();
Tom Cherry3b81f2d2017-07-28 14:48:41 -0700217 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700218
219 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700220}
221
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700222static Result<Success> do_export(const BuiltinArguments& args) {
Tom Cherry6de21f12017-08-22 15:41:03 -0700223 if (setenv(args[1].c_str(), args[2].c_str(), 1) == -1) {
224 return ErrnoError() << "setenv() failed";
Tom Cherry7fa62c52017-08-01 13:50:23 -0700225 }
226 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700227}
228
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700229static Result<Success> do_hostname(const BuiltinArguments& args) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700230 if (auto result = WriteFile("/proc/sys/kernel/hostname", args[1]); !result) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700231 return Error() << "Unable to write to /proc/sys/kernel/hostname: " << result.error();
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700232 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700233 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700234}
235
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700236static Result<Success> do_ifup(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700237 struct ifreq ifr;
238
239 strlcpy(ifr.ifr_name, args[1].c_str(), IFNAMSIZ);
240
241 unique_fd s(TEMP_FAILURE_RETRY(socket(AF_INET, SOCK_DGRAM, 0)));
242 if (s < 0) return ErrnoError() << "opening socket failed";
243
244 if (ioctl(s, SIOCGIFFLAGS, &ifr) < 0) {
245 return ErrnoError() << "ioctl(..., SIOCGIFFLAGS, ...) failed";
246 }
247
248 ifr.ifr_flags |= IFF_UP;
249
250 if (ioctl(s, SIOCSIFFLAGS, &ifr) < 0) {
251 return ErrnoError() << "ioctl(..., SIOCSIFFLAGS, ...) failed";
252 }
253
254 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700255}
256
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700257static Result<Success> do_insmod(const BuiltinArguments& args) {
Hung-ying Tyanbfa6d752016-05-17 18:49:10 +0800258 int flags = 0;
259 auto it = args.begin() + 1;
The Android Open Source Project35237d12008-12-17 18:08:08 -0800260
Hung-ying Tyanbfa6d752016-05-17 18:49:10 +0800261 if (!(*it).compare("-f")) {
262 flags = MODULE_INIT_IGNORE_VERMAGIC | MODULE_INIT_IGNORE_MODVERSIONS;
263 it++;
The Android Open Source Project35237d12008-12-17 18:08:08 -0800264 }
265
Hung-ying Tyanbfa6d752016-05-17 18:49:10 +0800266 std::string filename = *it++;
267 std::string options = android::base::Join(std::vector<std::string>(it, args.end()), ' ');
Tom Cherry7fa62c52017-08-01 13:50:23 -0700268
269 unique_fd fd(TEMP_FAILURE_RETRY(open(filename.c_str(), O_RDONLY | O_NOFOLLOW | O_CLOEXEC)));
270 if (fd == -1) return ErrnoError() << "open(\"" << filename << "\") failed";
271
272 int rc = syscall(__NR_finit_module, fd.get(), options.c_str(), flags);
273 if (rc == -1) return ErrnoError() << "finit_module for \"" << filename << "\" failed";
274
275 return Success();
The Android Open Source Project35237d12008-12-17 18:08:08 -0800276}
277
Steven Moreland612d7a42018-05-08 11:21:37 -0700278static Result<Success> do_interface_restart(const BuiltinArguments& args) {
279 Service* svc = ServiceList::GetInstance().FindInterface(args[1]);
280 if (!svc) return Error() << "interface " << args[1] << " not found";
281 svc->Restart();
282 return Success();
283}
284
285static Result<Success> do_interface_start(const BuiltinArguments& args) {
286 Service* svc = ServiceList::GetInstance().FindInterface(args[1]);
287 if (!svc) return Error() << "interface " << args[1] << " not found";
288 if (auto result = svc->Start(); !result) {
289 return Error() << "Could not start interface: " << result.error();
290 }
291 return Success();
292}
293
294static Result<Success> do_interface_stop(const BuiltinArguments& args) {
295 Service* svc = ServiceList::GetInstance().FindInterface(args[1]);
296 if (!svc) return Error() << "interface " << args[1] << " not found";
297 svc->Stop();
298 return Success();
299}
300
Tom Cherryc3692b32017-08-10 12:22:44 -0700301// mkdir <path> [mode] [owner] [group]
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700302static Result<Success> do_mkdir(const BuiltinArguments& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700303 mode_t mode = 0755;
Tom Cherry96f67312015-07-30 13:52:55 -0700304 if (args.size() >= 3) {
Elliott Hughesda46b392016-10-11 17:09:00 -0700305 mode = std::strtoul(args[2].c_str(), 0, 8);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700306 }
307
Tom Cherryc3692b32017-08-10 12:22:44 -0700308 if (!make_dir(args[1], mode)) {
309 /* chmod in case the directory already exists */
310 if (errno == EEXIST) {
311 if (fchmodat(AT_FDCWD, args[1].c_str(), mode, AT_SYMLINK_NOFOLLOW) == -1) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700312 return ErrnoError() << "fchmodat() failed";
Tom Cherryc3692b32017-08-10 12:22:44 -0700313 }
314 } else {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700315 return ErrnoError() << "mkdir() failed";
Tom Cherryc3692b32017-08-10 12:22:44 -0700316 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700317 }
318
Tom Cherry96f67312015-07-30 13:52:55 -0700319 if (args.size() >= 4) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700320 auto uid = DecodeUid(args[3]);
321 if (!uid) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700322 return Error() << "Unable to decode UID for '" << args[3] << "': " << uid.error();
Tom Cherry517e1f12017-05-04 17:40:33 -0700323 }
Tom Cherry62ca6632017-08-03 12:54:07 -0700324 Result<gid_t> gid = -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700325
Tom Cherry96f67312015-07-30 13:52:55 -0700326 if (args.size() == 5) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700327 gid = DecodeUid(args[4]);
328 if (!gid) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700329 return Error() << "Unable to decode GID for '" << args[3] << "': " << gid.error();
Tom Cherry517e1f12017-05-04 17:40:33 -0700330 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700331 }
332
Tom Cherry62ca6632017-08-03 12:54:07 -0700333 if (lchown(args[1].c_str(), *uid, *gid) == -1) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700334 return ErrnoError() << "lchown failed";
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700335 }
Benoit Goby5c8574b2012-08-14 15:43:46 -0700336
337 /* chown may have cleared S_ISUID and S_ISGID, chmod again */
338 if (mode & (S_ISUID | S_ISGID)) {
Tom Cherryc3692b32017-08-10 12:22:44 -0700339 if (fchmodat(AT_FDCWD, args[1].c_str(), mode, AT_SYMLINK_NOFOLLOW) == -1) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700340 return ErrnoError() << "fchmodat failed";
Benoit Goby5c8574b2012-08-14 15:43:46 -0700341 }
342 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700343 }
344
Eric Biggersf05da4a2018-10-23 13:10:33 -0700345 if (fscrypt_is_native()) {
346 if (fscrypt_set_directory_policy(args[1].c_str())) {
Paul Crowleyc73b2152018-04-13 17:38:57 +0000347 return reboot_into_recovery(
348 {"--prompt_and_wipe_data", "--reason=set_policy_failed:"s + args[1]});
Paul Crowleyaf8be582016-05-10 08:52:06 -0700349 }
350 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700351 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700352}
353
Alex Light68ab20f2016-06-23 11:11:39 -0700354/* umount <path> */
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700355static Result<Success> do_umount(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700356 if (umount(args[1].c_str()) < 0) {
357 return ErrnoError() << "umount() failed";
358 }
359 return Success();
Alex Light68ab20f2016-06-23 11:11:39 -0700360}
361
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700362static struct {
363 const char *name;
364 unsigned flag;
365} mount_flags[] = {
366 { "noatime", MS_NOATIME },
Lars Svenssonb6ee25e2011-07-14 13:39:09 +0200367 { "noexec", MS_NOEXEC },
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700368 { "nosuid", MS_NOSUID },
369 { "nodev", MS_NODEV },
370 { "nodiratime", MS_NODIRATIME },
371 { "ro", MS_RDONLY },
372 { "rw", 0 },
373 { "remount", MS_REMOUNT },
Jeff Sharkeye50ac5f2012-08-14 11:34:34 -0700374 { "bind", MS_BIND },
375 { "rec", MS_REC },
376 { "unbindable", MS_UNBINDABLE },
377 { "private", MS_PRIVATE },
378 { "slave", MS_SLAVE },
379 { "shared", MS_SHARED },
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700380 { "defaults", 0 },
381 { 0, 0 },
382};
383
Ken Sumrall752923c2010-12-03 16:33:31 -0800384#define DATA_MNT_POINT "/data"
385
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700386/* mount <type> <device> <path> <flags ...> <options> */
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700387static Result<Success> do_mount(const BuiltinArguments& args) {
Tom Cherry70379912017-08-01 14:10:11 -0700388 const char* options = nullptr;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700389 unsigned flags = 0;
Tom Cherry70379912017-08-01 14:10:11 -0700390 bool wait = false;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700391
Tom Cherry70379912017-08-01 14:10:11 -0700392 for (size_t na = 4; na < args.size(); na++) {
393 size_t i;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700394 for (i = 0; mount_flags[i].name; i++) {
Tom Cherry96f67312015-07-30 13:52:55 -0700395 if (!args[na].compare(mount_flags[i].name)) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700396 flags |= mount_flags[i].flag;
397 break;
398 }
399 }
400
Colin Crosscd0f1732010-04-19 17:10:24 -0700401 if (!mount_flags[i].name) {
Tom Cherry70379912017-08-01 14:10:11 -0700402 if (!args[na].compare("wait")) {
403 wait = true;
404 // If our last argument isn't a flag, wolf it up as an option string.
405 } else if (na + 1 == args.size()) {
Tom Cherry96f67312015-07-30 13:52:55 -0700406 options = args[na].c_str();
Tom Cherry70379912017-08-01 14:10:11 -0700407 }
Colin Crosscd0f1732010-04-19 17:10:24 -0700408 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700409 }
410
Tom Cherry70379912017-08-01 14:10:11 -0700411 const char* system = args[1].c_str();
412 const char* source = args[2].c_str();
413 const char* target = args[3].c_str();
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000414
Tom Cherry70379912017-08-01 14:10:11 -0700415 if (android::base::StartsWith(source, "loop@")) {
416 int mode = (flags & MS_RDONLY) ? O_RDONLY : O_RDWR;
417 unique_fd fd(TEMP_FAILURE_RETRY(open(source + 5, mode | O_CLOEXEC)));
Tom Cherry7fa62c52017-08-01 13:50:23 -0700418 if (fd < 0) return ErrnoError() << "open(" << source + 5 << ", " << mode << ") failed";
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000419
Tom Cherry70379912017-08-01 14:10:11 -0700420 for (size_t n = 0;; n++) {
421 std::string tmp = android::base::StringPrintf("/dev/block/loop%zu", n);
422 unique_fd loop(TEMP_FAILURE_RETRY(open(tmp.c_str(), mode | O_CLOEXEC)));
Tom Cherry7fa62c52017-08-01 13:50:23 -0700423 if (loop < 0) return ErrnoError() << "open(" << tmp << ", " << mode << ") failed";
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000424
Tom Cherry70379912017-08-01 14:10:11 -0700425 loop_info info;
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000426 /* if it is a blank loop device */
427 if (ioctl(loop, LOOP_GET_STATUS, &info) < 0 && errno == ENXIO) {
428 /* if it becomes our loop device */
Tom Cherry70379912017-08-01 14:10:11 -0700429 if (ioctl(loop, LOOP_SET_FD, fd.get()) >= 0) {
430 if (mount(tmp.c_str(), target, system, flags, options) < 0) {
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000431 ioctl(loop, LOOP_CLR_FD, 0);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700432 return ErrnoError() << "mount() failed";
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000433 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700434 return Success();
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000435 }
436 }
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000437 }
438
Tom Cherry7fa62c52017-08-01 13:50:23 -0700439 return Error() << "out of loopback devices";
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000440 } else {
Colin Crosscd0f1732010-04-19 17:10:24 -0700441 if (wait)
Elliott Hughes9605a942016-11-10 17:43:47 -0800442 wait_for_file(source, kCommandRetryTimeout);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000443 if (mount(source, target, system, flags, options) < 0) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700444 return ErrnoError() << "mount() failed";
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000445 }
446
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700447 }
Ken Sumralldd4d7862011-02-17 18:09:47 -0800448
Tom Cherry7fa62c52017-08-01 13:50:23 -0700449 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700450}
451
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800452/* Imports .rc files from the specified paths. Default ones are applied if none is given.
453 *
454 * start_index: index of the first path in the args list
455 */
Wei Wangd61a7e22016-08-23 11:58:09 -0700456static void import_late(const std::vector<std::string>& args, size_t start_index, size_t end_index) {
Tom Cherry67dee622017-07-27 12:54:48 -0700457 auto& action_manager = ActionManager::GetInstance();
Tom Cherry911b9b12017-07-27 16:20:58 -0700458 auto& service_list = ServiceList::GetInstance();
459 Parser parser = CreateParser(action_manager, service_list);
Wei Wangd61a7e22016-08-23 11:58:09 -0700460 if (end_index <= start_index) {
Jaekyun Seok4ec72cc2017-02-22 20:37:57 +0900461 // Fallbacks for partitions on which early mount isn't enabled.
Tom Cherry67dee622017-07-27 12:54:48 -0700462 for (const auto& path : late_import_paths) {
463 parser.ParseConfig(path);
Jaekyun Seok4ec72cc2017-02-22 20:37:57 +0900464 }
Tom Cherry67dee622017-07-27 12:54:48 -0700465 late_import_paths.clear();
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800466 } else {
Wei Wangd61a7e22016-08-23 11:58:09 -0700467 for (size_t i = start_index; i < end_index; ++i) {
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800468 parser.ParseConfig(args[i]);
469 }
Tom Cherryb8dd0272015-07-22 14:23:33 -0700470 }
Tom Cherryd8a72572017-03-13 12:24:49 -0700471
472 // Turning this on and letting the INFO logging be discarded adds 0.2s to
473 // Nexus 9 boot time, so it's disabled by default.
Tom Cherry30a6f272017-04-19 15:31:58 -0700474 if (false) DumpState();
Tom Cherryb8dd0272015-07-22 14:23:33 -0700475}
476
Yifan Hong81f13852019-04-09 10:11:34 -0700477/* handle_fstab
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800478 *
Yifan Hong81f13852019-04-09 10:11:34 -0700479 * Read the given fstab file and execute func on it.
JP Abgrallcee20682014-07-02 14:26:54 -0700480 */
Yifan Hong81f13852019-04-09 10:11:34 -0700481static Result<int> handle_fstab(const std::string& fstabfile, std::function<int(Fstab*)> func) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700482 /*
Yifan Hong81f13852019-04-09 10:11:34 -0700483 * Call fs_mgr_[u]mount_all() to [u]mount all filesystems. We fork(2) and
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700484 * do the call in the child to provide protection to the main init
485 * process if anything goes wrong (crash or memory leak), and wait for
486 * the child to finish in the parent.
487 */
Elliott Hughes7bc87a52016-08-04 16:09:39 -0700488 pid_t pid = fork();
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700489 if (pid > 0) {
490 /* Parent. Wait for the child to return */
Elliott Hughes7bc87a52016-08-04 16:09:39 -0700491 int status;
Paul Lawrence40af0922014-09-16 14:31:23 -0700492 int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700493 if (wp_ret == -1) {
494 // Unexpected error code. We will continue anyway.
495 PLOG(WARNING) << "waitpid failed";
Paul Lawrence40af0922014-09-16 14:31:23 -0700496 }
497
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700498 if (WIFEXITED(status)) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700499 return WEXITSTATUS(status);
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700500 } else {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700501 return Error() << "child aborted";
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700502 }
503 } else if (pid == 0) {
Yifan Hong81f13852019-04-09 10:11:34 -0700504 /* child, call fs_mgr_[u]mount_all() */
Elliott Hughes7bc87a52016-08-04 16:09:39 -0700505
Yifan Hong81f13852019-04-09 10:11:34 -0700506 // So we can always see what fs_mgr_[u]mount_all() does.
Elliott Hughes7bc87a52016-08-04 16:09:39 -0700507 // Only needed if someone explicitly changes the default log level in their init.rc.
508 android::base::ScopedLogSeverity info(android::base::INFO);
509
Tom Cherry23319eb2018-11-30 16:16:05 -0800510 Fstab fstab;
511 ReadFstabFromFile(fstabfile, &fstab);
512
Yifan Hong81f13852019-04-09 10:11:34 -0700513 int child_ret = func(&fstab);
514
JP Abgrallf22b7452014-07-02 13:16:04 -0700515 _exit(child_ret);
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700516 } else {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700517 return Error() << "fork() failed";
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700518 }
Wei Wangd61a7e22016-08-23 11:58:09 -0700519}
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700520
Yifan Hong81f13852019-04-09 10:11:34 -0700521/* mount_fstab
522 *
523 * Call fs_mgr_mount_all() to mount the given fstab
524 */
525static Result<int> mount_fstab(const std::string& fstabfile, int mount_mode) {
526 return handle_fstab(fstabfile, [mount_mode](Fstab* fstab) {
527 int ret = fs_mgr_mount_all(fstab, mount_mode);
528 if (ret == -1) {
529 PLOG(ERROR) << "fs_mgr_mount_all returned an error";
530 }
531 return ret;
532 });
533}
534
535/* umount_fstab
536 *
537 * Call fs_mgr_umount_all() to umount the given fstab
538 */
539static Result<int> umount_fstab(const std::string& fstabfile) {
540 return handle_fstab(fstabfile, [](Fstab* fstab) {
541 int ret = fs_mgr_umount_all(fstab);
542 if (ret != 0) {
543 PLOG(ERROR) << "fs_mgr_umount_all returned " << ret;
544 }
545 return ret;
546 });
547}
548
Wei Wangd61a7e22016-08-23 11:58:09 -0700549/* Queue event based on fs_mgr return code.
550 *
551 * code: return code of fs_mgr_mount_all
552 *
553 * This function might request a reboot, in which case it will
554 * not return.
555 *
556 * return code is processed based on input code
557 */
Tom Cherry7fa62c52017-08-01 13:50:23 -0700558static Result<Success> queue_fs_event(int code) {
Wei Wangd61a7e22016-08-23 11:58:09 -0700559 if (code == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
Paul Lawrence1f992182016-04-18 15:37:31 -0700560 ActionManager::GetInstance().QueueEventTrigger("encrypt");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700561 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700562 } else if (code == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700563 property_set("ro.crypto.state", "encrypted");
Paul Lawrence806d10b2015-04-28 22:07:10 +0000564 property_set("ro.crypto.type", "block");
Paul Lawrence1f992182016-04-18 15:37:31 -0700565 ActionManager::GetInstance().QueueEventTrigger("defaultcrypto");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700566 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700567 } else if (code == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700568 property_set("ro.crypto.state", "unencrypted");
Paul Lawrence1098aac2016-03-04 15:52:33 -0800569 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700570 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700571 } else if (code == FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE) {
Paul Lawrence1098aac2016-03-04 15:52:33 -0800572 property_set("ro.crypto.state", "unsupported");
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700573 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700574 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700575 } else if (code == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
JP Abgrallcee20682014-07-02 14:26:54 -0700576 /* Setup a wipe via recovery, and reboot into recovery */
David Anderson0e330f12019-01-03 18:16:56 -0800577 if (android::gsi::IsGsiRunning()) {
578 return Error() << "cannot wipe within GSI";
579 }
Elliott Hughesf86b5a62016-06-24 15:12:21 -0700580 PLOG(ERROR) << "fs_mgr_mount_all suggested recovery, so wiping data via recovery.";
Paul Crowley0b8b2302016-12-19 13:03:47 -0800581 const std::vector<std::string> options = {"--wipe_data", "--reason=fs_mgr_mount_all" };
Paul Crowleyc73b2152018-04-13 17:38:57 +0000582 return reboot_into_recovery(options);
JP Abgrallcee20682014-07-02 14:26:54 -0700583 /* If reboot worked, there is no return. */
Wei Wangd61a7e22016-08-23 11:58:09 -0700584 } else if (code == FS_MGR_MNTALL_DEV_FILE_ENCRYPTED) {
Eric Biggersf05da4a2018-10-23 13:10:33 -0700585 if (fscrypt_install_keyring()) {
586 return Error() << "fscrypt_install_keyring() failed";
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000587 }
588 property_set("ro.crypto.state", "encrypted");
Paul Lawrence806d10b2015-04-28 22:07:10 +0000589 property_set("ro.crypto.type", "file");
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000590
591 // Although encrypted, we have device key, so we do not need to
592 // do anything different from the nonencrypted case.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700593 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700594 return Success();
Paul Lawrence9dbe97b2017-04-21 12:41:48 -0700595 } else if (code == FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED) {
Eric Biggersf05da4a2018-10-23 13:10:33 -0700596 if (fscrypt_install_keyring()) {
597 return Error() << "fscrypt_install_keyring() failed";
Paul Lawrence9dbe97b2017-04-21 12:41:48 -0700598 }
599 property_set("ro.crypto.state", "encrypted");
600 property_set("ro.crypto.type", "file");
601
Paul Crowleyc6846962018-01-30 09:56:03 -0800602 // Although encrypted, vold has already set the device up, so we do not need to
603 // do anything different from the nonencrypted case.
604 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700605 return Success();
Paul Lawrence9dbe97b2017-04-21 12:41:48 -0700606 } else if (code == FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION) {
Eric Biggersf05da4a2018-10-23 13:10:33 -0700607 if (fscrypt_install_keyring()) {
608 return Error() << "fscrypt_install_keyring() failed";
Paul Lawrence9dbe97b2017-04-21 12:41:48 -0700609 }
Paul Crowleye3833342018-04-17 12:28:12 -0700610 property_set("ro.crypto.state", "encrypted");
Paul Lawrence9dbe97b2017-04-21 12:41:48 -0700611 property_set("ro.crypto.type", "file");
612
Paul Crowleyc6846962018-01-30 09:56:03 -0800613 // Although encrypted, vold has already set the device up, so we do not need to
614 // do anything different from the nonencrypted case.
615 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Tom Cherry7fa62c52017-08-01 13:50:23 -0700616 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700617 } else if (code > 0) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700618 Error() << "fs_mgr_mount_all() returned unexpected error " << code;
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700619 }
JP Abgrallf22b7452014-07-02 13:16:04 -0700620 /* else ... < 0: error */
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700621
Tom Cherry7fa62c52017-08-01 13:50:23 -0700622 return Error() << "Invalid code: " << code;
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700623}
624
Wei Wangd61a7e22016-08-23 11:58:09 -0700625/* mount_all <fstab> [ <path> ]* [--<options>]*
626 *
627 * This function might request a reboot, in which case it will
628 * not return.
629 */
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700630static Result<Success> do_mount_all(const BuiltinArguments& args) {
Wei Wangd61a7e22016-08-23 11:58:09 -0700631 std::size_t na = 0;
632 bool import_rc = true;
633 bool queue_event = true;
634 int mount_mode = MOUNT_MODE_DEFAULT;
Yifan Hong81f13852019-04-09 10:11:34 -0700635 const auto& fstabfile = args[1];
Wei Wangd61a7e22016-08-23 11:58:09 -0700636 std::size_t path_arg_end = args.size();
Keun-young Park69fae7b2017-03-03 18:57:09 -0800637 const char* prop_post_fix = "default";
Wei Wangd61a7e22016-08-23 11:58:09 -0700638
639 for (na = args.size() - 1; na > 1; --na) {
640 if (args[na] == "--early") {
Wei Wangd67a4ab2016-11-16 12:08:30 -0800641 path_arg_end = na;
642 queue_event = false;
643 mount_mode = MOUNT_MODE_EARLY;
Keun-young Park69fae7b2017-03-03 18:57:09 -0800644 prop_post_fix = "early";
Wei Wangd61a7e22016-08-23 11:58:09 -0700645 } else if (args[na] == "--late") {
646 path_arg_end = na;
647 import_rc = false;
648 mount_mode = MOUNT_MODE_LATE;
Keun-young Park69fae7b2017-03-03 18:57:09 -0800649 prop_post_fix = "late";
Wei Wangd61a7e22016-08-23 11:58:09 -0700650 }
651 }
652
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700653 std::string prop_name = "ro.boottime.init.mount_all."s + prop_post_fix;
Tom Cherryede0d532017-07-06 14:20:11 -0700654 android::base::Timer t;
Tom Cherry7fa62c52017-08-01 13:50:23 -0700655 auto mount_fstab_return_code = mount_fstab(fstabfile, mount_mode);
656 if (!mount_fstab_return_code) {
657 return Error() << "mount_fstab() failed " << mount_fstab_return_code.error();
658 }
Tom Cherryede0d532017-07-06 14:20:11 -0700659 property_set(prop_name, std::to_string(t.duration().count()));
Wei Wangd61a7e22016-08-23 11:58:09 -0700660
661 if (import_rc) {
662 /* Paths of .rc files are specified at the 2nd argument and beyond */
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700663 import_late(args.args, 2, path_arg_end);
Wei Wangd61a7e22016-08-23 11:58:09 -0700664 }
665
666 if (queue_event) {
667 /* queue_fs_event will queue event based on mount_fstab return code
668 * and return processed return code*/
Tom Cherry7fa62c52017-08-01 13:50:23 -0700669 auto queue_fs_result = queue_fs_event(*mount_fstab_return_code);
670 if (!queue_fs_result) {
671 return Error() << "queue_fs_event() failed: " << queue_fs_result.error();
672 }
Wei Wangd61a7e22016-08-23 11:58:09 -0700673 }
674
Tom Cherry7fa62c52017-08-01 13:50:23 -0700675 return Success();
Wei Wangd61a7e22016-08-23 11:58:09 -0700676}
677
Yifan Hong81f13852019-04-09 10:11:34 -0700678/* umount_all <fstab> */
679static Result<Success> do_umount_all(const BuiltinArguments& args) {
680 auto umount_fstab_return_code = umount_fstab(args[1]);
681 if (!umount_fstab_return_code) {
682 return Error() << "umount_fstab() failed " << umount_fstab_return_code.error();
683 }
684 return Success();
685}
686
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700687static Result<Success> do_swapon_all(const BuiltinArguments& args) {
Tom Cherry30554572018-11-30 15:21:04 -0800688 Fstab fstab;
689 if (!ReadFstabFromFile(args[1], &fstab)) {
690 return Error() << "Could not read fstab '" << args[1] << "'";
691 }
Ken Sumralla76baaa2013-07-09 18:42:09 -0700692
Tom Cherry30554572018-11-30 15:21:04 -0800693 if (!fs_mgr_swapon_all(fstab)) {
694 return Error() << "fs_mgr_swapon_all() failed";
695 }
Ken Sumralla76baaa2013-07-09 18:42:09 -0700696
Tom Cherry7fa62c52017-08-01 13:50:23 -0700697 return Success();
Ken Sumralla76baaa2013-07-09 18:42:09 -0700698}
699
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700700static Result<Success> do_setprop(const BuiltinArguments& args) {
Tom Cherry1c3a53f2017-06-22 16:50:31 -0700701 property_set(args[1], args[2]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700702 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700703}
704
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700705static Result<Success> do_setrlimit(const BuiltinArguments& args) {
706 auto rlimit = ParseRlimit(args.args);
Tom Cherry7ac013d2017-08-25 10:39:25 -0700707 if (!rlimit) return rlimit.error();
Tom Cherry7fa62c52017-08-01 13:50:23 -0700708
Tom Cherry7ac013d2017-08-25 10:39:25 -0700709 if (setrlimit(rlimit->first, &rlimit->second) == -1) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700710 return ErrnoError() << "setrlimit failed";
711 }
712 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700713}
714
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700715static Result<Success> do_start(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700716 Service* svc = ServiceList::GetInstance().FindService(args[1]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700717 if (!svc) return Error() << "service " << args[1] << " not found";
Tom Cherry76af7e62017-08-22 16:13:59 -0700718 if (auto result = svc->Start(); !result) {
719 return Error() << "Could not start service: " << result.error();
720 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700721 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700722}
723
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700724static Result<Success> do_stop(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700725 Service* svc = ServiceList::GetInstance().FindService(args[1]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700726 if (!svc) return Error() << "service " << args[1] << " not found";
Tom Cherrybac32992015-07-31 12:45:25 -0700727 svc->Stop();
Tom Cherry7fa62c52017-08-01 13:50:23 -0700728 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700729}
730
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700731static Result<Success> do_restart(const BuiltinArguments& args) {
Tom Cherry911b9b12017-07-27 16:20:58 -0700732 Service* svc = ServiceList::GetInstance().FindService(args[1]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700733 if (!svc) return Error() << "service " << args[1] << " not found";
Tom Cherrybac32992015-07-31 12:45:25 -0700734 svc->Restart();
Tom Cherry7fa62c52017-08-01 13:50:23 -0700735 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700736}
737
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700738static Result<Success> do_trigger(const BuiltinArguments& args) {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700739 ActionManager::GetInstance().QueueEventTrigger(args[1]);
Tom Cherry7fa62c52017-08-01 13:50:23 -0700740 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700741}
742
Joel Galenson4b591f12017-11-27 14:45:26 -0800743static int MakeSymlink(const std::string& target, const std::string& linkpath) {
744 std::string secontext;
745 // Passing 0 for mode should work.
746 if (SelabelLookupFileContext(linkpath, 0, &secontext) && !secontext.empty()) {
747 setfscreatecon(secontext.c_str());
748 }
749
750 int rc = symlink(target.c_str(), linkpath.c_str());
751
752 if (!secontext.empty()) {
753 int save_errno = errno;
754 setfscreatecon(nullptr);
755 errno = save_errno;
756 }
757
758 return rc;
759}
760
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700761static Result<Success> do_symlink(const BuiltinArguments& args) {
Joel Galenson4b591f12017-11-27 14:45:26 -0800762 if (MakeSymlink(args[1], args[2]) < 0) {
Tom Cherry68f2a462017-08-22 16:15:26 -0700763 // The symlink builtin is often used to create symlinks for older devices to be backwards
764 // compatible with new paths, therefore we skip reporting this error.
765 if (errno == EEXIST && android::base::GetMinimumLogSeverity() > android::base::DEBUG) {
766 return Success();
767 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700768 return ErrnoError() << "symlink() failed";
Elliott Hughesda46b392016-10-11 17:09:00 -0700769 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700770 return Success();
The Android Open Source Project35237d12008-12-17 18:08:08 -0800771}
772
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700773static Result<Success> do_rm(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700774 if (unlink(args[1].c_str()) < 0) {
775 return ErrnoError() << "unlink() failed";
776 }
777 return Success();
778}
779
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700780static Result<Success> do_rmdir(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700781 if (rmdir(args[1].c_str()) < 0) {
782 return ErrnoError() << "rmdir() failed";
783 }
784 return Success();
785}
786
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700787static Result<Success> do_sysclktz(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700788 struct timezone tz = {};
789 if (!android::base::ParseInt(args[1], &tz.tz_minuteswest)) {
790 return Error() << "Unable to parse mins_west_of_gmt";
791 }
792
793 if (settimeofday(nullptr, &tz) == -1) {
794 return ErrnoError() << "settimeofday() failed";
795 }
796 return Success();
797}
798
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700799static Result<Success> do_verity_load_state(const BuiltinArguments& args) {
Elliott Hughesdb3f2672015-03-20 09:45:18 -0700800 int mode = -1;
Bowgo Tsaiaaf70e72017-03-02 00:03:56 +0800801 bool loaded = fs_mgr_load_verity_state(&mode);
802 if (loaded && mode != VERITY_MODE_DEFAULT) {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700803 ActionManager::GetInstance().QueueEventTrigger("verity-logging");
Sami Tolvanen8ff01902015-02-16 11:03:34 +0000804 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700805 if (!loaded) return Error() << "Could not load verity state";
806
807 return Success();
Sami Tolvanen8ff01902015-02-16 11:03:34 +0000808}
809
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700810static Result<Success> do_verity_update_state(const BuiltinArguments& args) {
Tom Cherrycf80b6d2019-01-07 14:25:31 -0800811 int mode;
812 if (!fs_mgr_load_verity_state(&mode)) {
813 return Error() << "fs_mgr_load_verity_state() failed";
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700814 }
Tom Cherrycf80b6d2019-01-07 14:25:31 -0800815
816 Fstab fstab;
817 if (!ReadDefaultFstab(&fstab)) {
818 return Error() << "Failed to read default fstab";
819 }
820
821 for (const auto& entry : fstab) {
822 if (!fs_mgr_is_verity_enabled(entry)) {
823 continue;
824 }
825
826 // To be consistent in vboot 1.0 and vboot 2.0 (AVB), use "system" for the partition even
827 // for system as root, so it has property [partition.system.verified].
828 std::string partition = entry.mount_point == "/" ? "system" : Basename(entry.mount_point);
829 property_set("partition." + partition + ".verified", std::to_string(mode));
830 }
831
Tom Cherry7fa62c52017-08-01 13:50:23 -0700832 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700833}
834
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700835static Result<Success> do_write(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700836 if (auto result = WriteFile(args[1], args[2]); !result) {
837 return Error() << "Unable to write to file '" << args[1] << "': " << result.error();
838 }
839
840 return Success();
841}
842
Wei Wang02628f32017-08-16 11:34:50 -0700843static Result<Success> readahead_file(const std::string& filename, bool fully) {
844 android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filename.c_str(), O_RDONLY)));
845 if (fd == -1) {
846 return ErrnoError() << "Error opening file";
847 }
848 if (posix_fadvise(fd, 0, 0, POSIX_FADV_WILLNEED)) {
849 return ErrnoError() << "Error posix_fadvise file";
850 }
851 if (readahead(fd, 0, std::numeric_limits<size_t>::max())) {
852 return ErrnoError() << "Error readahead file";
853 }
854 if (fully) {
855 char buf[BUFSIZ];
856 ssize_t n;
857 while ((n = TEMP_FAILURE_RETRY(read(fd, &buf[0], sizeof(buf)))) > 0) {
858 }
859 if (n != 0) {
860 return ErrnoError() << "Error reading file";
861 }
862 }
863 return Success();
864}
865
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700866static Result<Success> do_readahead(const BuiltinArguments& args) {
Wei Wang542aae42017-08-04 13:22:36 -0700867 struct stat sb;
868
869 if (stat(args[1].c_str(), &sb)) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700870 return ErrnoError() << "Error opening " << args[1];
Wei Wang542aae42017-08-04 13:22:36 -0700871 }
872
Wei Wang02628f32017-08-16 11:34:50 -0700873 bool readfully = false;
874 if (args.size() == 3 && args[2] == "--fully") {
875 readfully = true;
876 }
Wei Wang542aae42017-08-04 13:22:36 -0700877 // We will do readahead in a forked process in order not to block init
878 // since it may block while it reads the
879 // filesystem metadata needed to locate the requested blocks. This
880 // occurs frequently with ext[234] on large files using indirect blocks
881 // instead of extents, giving the appearance that the call blocks until
882 // the requested data has been read.
883 pid_t pid = fork();
884 if (pid == 0) {
Wei Wang02628f32017-08-16 11:34:50 -0700885 if (setpriority(PRIO_PROCESS, 0, static_cast<int>(ANDROID_PRIORITY_LOWEST)) != 0) {
886 PLOG(WARNING) << "setpriority failed";
887 }
888 if (android_set_ioprio(0, IoSchedClass_IDLE, 7)) {
889 PLOG(WARNING) << "ioprio_get failed";
890 }
Wei Wang542aae42017-08-04 13:22:36 -0700891 android::base::Timer t;
892 if (S_ISREG(sb.st_mode)) {
Wei Wang02628f32017-08-16 11:34:50 -0700893 if (auto result = readahead_file(args[1], readfully); !result) {
894 LOG(WARNING) << "Unable to readahead '" << args[1] << "': " << result.error();
Wei Wang542aae42017-08-04 13:22:36 -0700895 _exit(EXIT_FAILURE);
896 }
897 } else if (S_ISDIR(sb.st_mode)) {
898 char* paths[] = {const_cast<char*>(args[1].data()), nullptr};
899 std::unique_ptr<FTS, decltype(&fts_close)> fts(
900 fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR | FTS_XDEV, nullptr), fts_close);
901 if (!fts) {
902 PLOG(ERROR) << "Error opening directory: " << args[1];
903 _exit(EXIT_FAILURE);
904 }
905 // Traverse the entire hierarchy and do readahead
906 for (FTSENT* ftsent = fts_read(fts.get()); ftsent != nullptr;
907 ftsent = fts_read(fts.get())) {
908 if (ftsent->fts_info & FTS_F) {
Wei Wang02628f32017-08-16 11:34:50 -0700909 const std::string filename = ftsent->fts_accpath;
910 if (auto result = readahead_file(filename, readfully); !result) {
911 LOG(WARNING)
912 << "Unable to readahead '" << filename << "': " << result.error();
Wei Wang542aae42017-08-04 13:22:36 -0700913 }
914 }
915 }
916 }
Wei Wang02628f32017-08-16 11:34:50 -0700917 LOG(INFO) << "Readahead " << args[1] << " took " << t << " asynchronously";
Wei Wang542aae42017-08-04 13:22:36 -0700918 _exit(0);
919 } else if (pid < 0) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700920 return ErrnoError() << "Fork failed";
Wei Wang542aae42017-08-04 13:22:36 -0700921 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700922 return Success();
Wei Wang542aae42017-08-04 13:22:36 -0700923}
924
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700925static Result<Success> do_copy(const BuiltinArguments& args) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700926 auto file_contents = ReadFile(args[1]);
927 if (!file_contents) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700928 return Error() << "Could not read input file '" << args[1] << "': " << file_contents.error();
San Mehat7c44fe52009-08-26 16:39:25 -0700929 }
Tom Cherry62ca6632017-08-03 12:54:07 -0700930 if (auto result = WriteFile(args[2], *file_contents); !result) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700931 return Error() << "Could not write to output file '" << args[2] << "': " << result.error();
Tom Cherry2cbbe9f2017-05-04 18:17:33 -0700932 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700933
934 return Success();
San Mehat7c44fe52009-08-26 16:39:25 -0700935}
936
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700937static Result<Success> do_chown(const BuiltinArguments& args) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700938 auto uid = DecodeUid(args[1]);
939 if (!uid) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700940 return Error() << "Unable to decode UID for '" << args[1] << "': " << uid.error();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700941 }
Tom Cherry517e1f12017-05-04 17:40:33 -0700942
943 // GID is optional and pushes the index of path out by one if specified.
944 const std::string& path = (args.size() == 4) ? args[3] : args[2];
Tom Cherry62ca6632017-08-03 12:54:07 -0700945 Result<gid_t> gid = -1;
Tom Cherry517e1f12017-05-04 17:40:33 -0700946
947 if (args.size() == 4) {
Tom Cherry62ca6632017-08-03 12:54:07 -0700948 gid = DecodeUid(args[2]);
949 if (!gid) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700950 return Error() << "Unable to decode GID for '" << args[2] << "': " << gid.error();
Tom Cherry517e1f12017-05-04 17:40:33 -0700951 }
952 }
953
Tom Cherry7fa62c52017-08-01 13:50:23 -0700954 if (lchown(path.c_str(), *uid, *gid) == -1) {
955 return ErrnoError() << "lchown() failed";
956 }
Tom Cherry517e1f12017-05-04 17:40:33 -0700957
Tom Cherry7fa62c52017-08-01 13:50:23 -0700958 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700959}
960
961static mode_t get_mode(const char *s) {
962 mode_t mode = 0;
963 while (*s) {
964 if (*s >= '0' && *s <= '7') {
965 mode = (mode<<3) | (*s-'0');
966 } else {
967 return -1;
968 }
969 s++;
970 }
971 return mode;
972}
973
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700974static Result<Success> do_chmod(const BuiltinArguments& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700975 mode_t mode = get_mode(args[1].c_str());
976 if (fchmodat(AT_FDCWD, args[2].c_str(), mode, AT_SYMLINK_NOFOLLOW) < 0) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700977 return ErrnoError() << "fchmodat() failed";
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700978 }
Tom Cherry7fa62c52017-08-01 13:50:23 -0700979 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700980}
981
Tom Cherrycb0f9bb2017-09-12 15:58:47 -0700982static Result<Success> do_restorecon(const BuiltinArguments& args) {
Stephen Smalley726e8f72013-10-09 16:02:09 -0400983 int ret = 0;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500984
Paul Lawrencea8d84342016-11-14 15:40:18 -0800985 struct flag_type {const char* name; int value;};
986 static const flag_type flags[] = {
987 {"--recursive", SELINUX_ANDROID_RESTORECON_RECURSE},
988 {"--skip-ce", SELINUX_ANDROID_RESTORECON_SKIPCE},
989 {"--cross-filesystems", SELINUX_ANDROID_RESTORECON_CROSS_FILESYSTEMS},
990 {0, 0}
991 };
992
993 int flag = 0;
994
995 bool in_flags = true;
996 for (size_t i = 1; i < args.size(); ++i) {
997 if (android::base::StartsWith(args[i], "--")) {
998 if (!in_flags) {
Tom Cherry7fa62c52017-08-01 13:50:23 -0700999 return Error() << "flags must precede paths";
Paul Lawrencea8d84342016-11-14 15:40:18 -08001000 }
1001 bool found = false;
1002 for (size_t j = 0; flags[j].name; ++j) {
1003 if (args[i] == flags[j].name) {
1004 flag |= flags[j].value;
1005 found = true;
1006 break;
1007 }
1008 }
1009 if (!found) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001010 return Error() << "bad flag " << args[i];
Paul Lawrencea8d84342016-11-14 15:40:18 -08001011 }
1012 } else {
1013 in_flags = false;
Tom Cherryc2ef2f02017-05-08 13:38:15 -07001014 if (selinux_android_restorecon(args[i].c_str(), flag) < 0) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001015 ret = errno;
Paul Lawrencea8d84342016-11-14 15:40:18 -08001016 }
1017 }
Stephen Smalleye46f9d52012-01-13 08:48:47 -05001018 }
Tom Cherry7fa62c52017-08-01 13:50:23 -07001019
1020 if (ret) return ErrnoError() << "selinux_android_restorecon() failed";
1021 return Success();
Stephen Smalley726e8f72013-10-09 16:02:09 -04001022}
1023
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001024static Result<Success> do_restorecon_recursive(const BuiltinArguments& args) {
1025 std::vector<std::string> non_const_args(args.args);
Paul Lawrencea8d84342016-11-14 15:40:18 -08001026 non_const_args.insert(std::next(non_const_args.begin()), "--recursive");
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001027 return do_restorecon({std::move(non_const_args), args.context});
Stephen Smalleye46f9d52012-01-13 08:48:47 -05001028}
1029
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001030static Result<Success> do_loglevel(const BuiltinArguments& args) {
Elliott Hughes7bc87a52016-08-04 16:09:39 -07001031 // TODO: support names instead/as well?
Elliott Hughesda46b392016-10-11 17:09:00 -07001032 int log_level = -1;
1033 android::base::ParseInt(args[1], &log_level);
Elliott Hughes7bc87a52016-08-04 16:09:39 -07001034 android::base::LogSeverity severity;
1035 switch (log_level) {
1036 case 7: severity = android::base::DEBUG; break;
1037 case 6: severity = android::base::INFO; break;
1038 case 5:
1039 case 4: severity = android::base::WARNING; break;
1040 case 3: severity = android::base::ERROR; break;
1041 case 2:
1042 case 1:
1043 case 0: severity = android::base::FATAL; break;
1044 default:
Tom Cherry7fa62c52017-08-01 13:50:23 -07001045 return Error() << "invalid log level " << log_level;
Riley Andrews1bbef882014-06-26 13:55:03 -07001046 }
Elliott Hughes7bc87a52016-08-04 16:09:39 -07001047 android::base::SetMinimumLogSeverity(severity);
Tom Cherry7fa62c52017-08-01 13:50:23 -07001048 return Success();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -07001049}
1050
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001051static Result<Success> do_load_persist_props(const BuiltinArguments& args) {
Tom Cherryb7349902015-08-26 11:43:36 -07001052 load_persist_props();
Tom Cherry7fa62c52017-08-01 13:50:23 -07001053 return Success();
Ken Sumrallc5c51032011-03-08 17:01:29 -08001054}
1055
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001056static Result<Success> do_load_system_props(const BuiltinArguments& args) {
Jiyong Park3b316ee2019-01-13 02:42:31 +09001057 LOG(INFO) << "deprecated action `load_system_props` called.";
Tom Cherry7fa62c52017-08-01 13:50:23 -07001058 return Success();
Riley Andrewse4b7b292014-06-16 15:06:21 -07001059}
1060
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001061static Result<Success> do_wait(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001062 auto timeout = kCommandRetryTimeout;
1063 if (args.size() == 3) {
1064 int timeout_int;
1065 if (!android::base::ParseInt(args[2], &timeout_int)) {
1066 return Error() << "failed to parse timeout";
Elliott Hughesda46b392016-10-11 17:09:00 -07001067 }
Tom Cherry7fa62c52017-08-01 13:50:23 -07001068 timeout = std::chrono::seconds(timeout_int);
Elliott Hughesda46b392016-10-11 17:09:00 -07001069 }
Tom Cherry7fa62c52017-08-01 13:50:23 -07001070
1071 if (wait_for_file(args[1].c_str(), timeout) != 0) {
1072 return Error() << "wait_for_file() failed";
1073 }
1074
1075 return Success();
Colin Crosscd0f1732010-04-19 17:10:24 -07001076}
Paul Lawrenceb8c9d272015-03-26 15:49:42 +00001077
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001078static Result<Success> do_wait_for_prop(const BuiltinArguments& args) {
Wei Wang132ac312017-01-25 16:27:03 -08001079 const char* name = args[1].c_str();
1080 const char* value = args[2].c_str();
1081 size_t value_len = strlen(value);
1082
Tom Cherryde6bd502018-02-13 16:50:08 -08001083 if (!IsLegalPropertyName(name)) {
1084 return Error() << "IsLegalPropertyName(" << name << ") failed";
Wei Wang132ac312017-01-25 16:27:03 -08001085 }
1086 if (value_len >= PROP_VALUE_MAX) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001087 return Error() << "value too long";
Wei Wang132ac312017-01-25 16:27:03 -08001088 }
Wei Wang2d0fdaa2017-02-02 10:52:39 -08001089 if (!start_waiting_for_property(name, value)) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001090 return Error() << "already waiting for a property";
Wei Wang132ac312017-01-25 16:27:03 -08001091 }
Tom Cherry7fa62c52017-08-01 13:50:23 -07001092 return Success();
Wei Wang132ac312017-01-25 16:27:03 -08001093}
1094
Paul Crowley749af8c2015-05-28 17:35:06 +01001095static bool is_file_crypto() {
Tom Cherryccf23532017-03-28 16:40:41 -07001096 return android::base::GetProperty("ro.crypto.type", "") == "file";
Paul Crowley749af8c2015-05-28 17:35:06 +01001097}
1098
Paul Crowleyc73b2152018-04-13 17:38:57 +00001099static Result<Success> ExecWithRebootOnFailure(const std::string& reboot_reason,
1100 const BuiltinArguments& args) {
1101 auto service = Service::MakeTemporaryOneshotService(args.args);
1102 if (!service) {
1103 return Error() << "Could not create exec service";
1104 }
1105 service->AddReapCallback([reboot_reason](const siginfo_t& siginfo) {
1106 if (siginfo.si_code != CLD_EXITED || siginfo.si_status != 0) {
David Anderson0e330f12019-01-03 18:16:56 -08001107 // TODO (b/122850122): support this in gsi
1108 if (fscrypt_is_native() && !android::gsi::IsGsiRunning()) {
Paul Crowleyc73b2152018-04-13 17:38:57 +00001109 LOG(ERROR) << "Rebooting into recovery, reason: " << reboot_reason;
Tom Cherryd9872642018-10-11 10:38:05 -07001110 if (auto result = reboot_into_recovery(
1111 {"--prompt_and_wipe_data", "--reason="s + reboot_reason});
1112 !result) {
1113 LOG(FATAL) << "Could not reboot into recovery: " << result.error();
1114 }
Paul Crowleyc73b2152018-04-13 17:38:57 +00001115 } else {
1116 LOG(ERROR) << "Failure (reboot suppressed): " << reboot_reason;
1117 }
1118 }
1119 });
1120 if (auto result = service->ExecStart(); !result) {
1121 return Error() << "Could not start exec service: " << result.error();
1122 }
1123 ServiceList::GetInstance().AddService(std::move(service));
1124 return Success();
1125}
1126
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001127static Result<Success> do_installkey(const BuiltinArguments& args) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001128 if (!is_file_crypto()) return Success();
1129
Eric Biggersf05da4a2018-10-23 13:10:33 -07001130 auto unencrypted_dir = args[1] + fscrypt_unencrypted_folder;
Tom Cherryc3692b32017-08-10 12:22:44 -07001131 if (!make_dir(unencrypted_dir, 0700) && errno != EEXIST) {
Tom Cherry7fa62c52017-08-01 13:50:23 -07001132 return ErrnoError() << "Failed to create " << unencrypted_dir;
Janis Danisevskis9cc51722017-03-29 14:50:01 -07001133 }
Paul Crowleyc73b2152018-04-13 17:38:57 +00001134 return ExecWithRebootOnFailure(
1135 "enablefilecrypto_failed",
1136 {{"exec", "/system/bin/vdc", "--wait", "cryptfs", "enablefilecrypto"}, args.context});
Paul Lawrenceb8c9d272015-03-26 15:49:42 +00001137}
Paul Crowley749af8c2015-05-28 17:35:06 +01001138
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001139static Result<Success> do_init_user0(const BuiltinArguments& args) {
Paul Crowleyc73b2152018-04-13 17:38:57 +00001140 return ExecWithRebootOnFailure(
1141 "init_user0_failed",
1142 {{"exec", "/system/bin/vdc", "--wait", "cryptfs", "init_user0"}, args.context});
Paul Crowley59497452016-02-01 16:37:13 +00001143}
1144
Martijn Coenenf0bc58a2019-04-23 16:26:01 +02001145static Result<Success> do_mark_post_data(const BuiltinArguments& args) {
1146 ServiceList::GetInstance().MarkPostData();
1147
1148 return Success();
1149}
1150
Jiyong Parkc2404402018-11-08 17:14:35 +09001151static Result<Success> do_parse_apex_configs(const BuiltinArguments& args) {
1152 glob_t glob_result;
1153 // @ is added to filter out the later paths, which are bind mounts of the places
1154 // where the APEXes are really mounted at. Otherwise, we will parse the
1155 // same file twice.
1156 static constexpr char glob_pattern[] = "/apex/*@*/etc/*.rc";
Jiyong Parkf169f722018-11-16 16:23:20 +09001157 const int ret = glob(glob_pattern, GLOB_MARK, nullptr, &glob_result);
1158 if (ret != 0 && ret != GLOB_NOMATCH) {
Jiyong Parkc2404402018-11-08 17:14:35 +09001159 globfree(&glob_result);
1160 return Error() << "glob pattern '" << glob_pattern << "' failed";
1161 }
1162 std::vector<std::string> configs;
1163 Parser parser = CreateServiceOnlyParser(ServiceList::GetInstance());
1164 for (size_t i = 0; i < glob_result.gl_pathc; i++) {
1165 configs.emplace_back(glob_result.gl_pathv[i]);
1166 }
1167 globfree(&glob_result);
1168
1169 bool success = true;
1170 for (const auto& c : configs) {
1171 if (c.back() == '/') {
1172 // skip if directory
1173 continue;
1174 }
1175 success &= parser.ParseConfigFile(c);
1176 }
Jiyong Park80aa4472018-11-12 12:08:41 +09001177 ServiceList::GetInstance().MarkServicesUpdate();
Jiyong Parkc2404402018-11-08 17:14:35 +09001178 if (success) {
1179 return Success();
1180 } else {
1181 return Error() << "Could not parse apex configs";
1182 }
1183}
1184
Jiyong Parkdcbaf9f2019-02-22 22:15:25 +09001185static Result<Success> do_enter_default_mount_ns(const BuiltinArguments& args) {
1186 if (SwitchToDefaultMountNamespace()) {
1187 return Success();
1188 } else {
1189 return Error() << "Failed to enter into default mount namespace";
1190 }
1191}
1192
Tom Cherryde6bd502018-02-13 16:50:08 -08001193// Builtin-function-map start
Tom Cherryad54d092017-04-19 16:18:50 -07001194const BuiltinFunctionMap::Map& BuiltinFunctionMap::map() const {
Tom Cherryb7349902015-08-26 11:43:36 -07001195 constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
Tom Cherryb27004a2017-03-27 16:27:30 -07001196 // clang-format off
Tom Cherryb7349902015-08-26 11:43:36 -07001197 static const Map builtin_functions = {
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001198 {"bootchart", {1, 1, {false, do_bootchart}}},
1199 {"chmod", {2, 2, {true, do_chmod}}},
1200 {"chown", {2, 3, {true, do_chown}}},
1201 {"class_reset", {1, 1, {false, do_class_reset}}},
Martijn Coenenf0bc58a2019-04-23 16:26:01 +02001202 {"class_reset_post_data", {1, 1, {false, do_class_reset_post_data}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001203 {"class_restart", {1, 1, {false, do_class_restart}}},
1204 {"class_start", {1, 1, {false, do_class_start}}},
Martijn Coenenf0bc58a2019-04-23 16:26:01 +02001205 {"class_start_post_data", {1, 1, {false, do_class_start_post_data}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001206 {"class_stop", {1, 1, {false, do_class_stop}}},
1207 {"copy", {2, 2, {true, do_copy}}},
1208 {"domainname", {1, 1, {true, do_domainname}}},
1209 {"enable", {1, 1, {false, do_enable}}},
1210 {"exec", {1, kMax, {false, do_exec}}},
1211 {"exec_background", {1, kMax, {false, do_exec_background}}},
1212 {"exec_start", {1, 1, {false, do_exec_start}}},
1213 {"export", {2, 2, {false, do_export}}},
1214 {"hostname", {1, 1, {true, do_hostname}}},
1215 {"ifup", {1, 1, {true, do_ifup}}},
1216 {"init_user0", {0, 0, {false, do_init_user0}}},
1217 {"insmod", {1, kMax, {true, do_insmod}}},
1218 {"installkey", {1, 1, {false, do_installkey}}},
Steven Moreland612d7a42018-05-08 11:21:37 -07001219 {"interface_restart", {1, 1, {false, do_interface_restart}}},
1220 {"interface_start", {1, 1, {false, do_interface_start}}},
1221 {"interface_stop", {1, 1, {false, do_interface_stop}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001222 {"load_persist_props", {0, 0, {false, do_load_persist_props}}},
1223 {"load_system_props", {0, 0, {false, do_load_system_props}}},
1224 {"loglevel", {1, 1, {false, do_loglevel}}},
Martijn Coenenf0bc58a2019-04-23 16:26:01 +02001225 {"mark_post_data", {0, 0, {false, do_mark_post_data}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001226 {"mkdir", {1, 4, {true, do_mkdir}}},
Tom Cherry880d5662018-02-05 08:01:54 -08001227 // TODO: Do mount operations in vendor_init.
1228 // mount_all is currently too complex to run in vendor_init as it queues action triggers,
1229 // imports rc scripts, etc. It should be simplified and run in vendor_init context.
1230 // mount and umount are run in the same context as mount_all for symmetry.
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001231 {"mount_all", {1, kMax, {false, do_mount_all}}},
1232 {"mount", {3, kMax, {false, do_mount}}},
Jiyong Parkc2404402018-11-08 17:14:35 +09001233 {"parse_apex_configs", {0, 0, {false, do_parse_apex_configs}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001234 {"umount", {1, 1, {false, do_umount}}},
Yifan Hong81f13852019-04-09 10:11:34 -07001235 {"umount_all", {1, 1, {false, do_umount_all}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001236 {"readahead", {1, 2, {true, do_readahead}}},
1237 {"restart", {1, 1, {false, do_restart}}},
1238 {"restorecon", {1, kMax, {true, do_restorecon}}},
1239 {"restorecon_recursive", {1, kMax, {true, do_restorecon_recursive}}},
1240 {"rm", {1, 1, {true, do_rm}}},
1241 {"rmdir", {1, 1, {true, do_rmdir}}},
Tom Cherry32228482018-01-18 16:14:25 -08001242 {"setprop", {2, 2, {true, do_setprop}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001243 {"setrlimit", {3, 3, {false, do_setrlimit}}},
1244 {"start", {1, 1, {false, do_start}}},
1245 {"stop", {1, 1, {false, do_stop}}},
1246 {"swapon_all", {1, 1, {false, do_swapon_all}}},
Jiyong Parkdcbaf9f2019-02-22 22:15:25 +09001247 {"enter_default_mount_ns", {0, 0, {false, do_enter_default_mount_ns}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001248 {"symlink", {2, 2, {true, do_symlink}}},
1249 {"sysclktz", {1, 1, {false, do_sysclktz}}},
1250 {"trigger", {1, 1, {false, do_trigger}}},
1251 {"verity_load_state", {0, 0, {false, do_verity_load_state}}},
1252 {"verity_update_state", {0, 0, {false, do_verity_update_state}}},
1253 {"wait", {1, 2, {true, do_wait}}},
Tom Cherryfa3e52c2017-10-17 10:43:52 -07001254 {"wait_for_prop", {2, 2, {false, do_wait_for_prop}}},
Tom Cherrycb0f9bb2017-09-12 15:58:47 -07001255 {"write", {2, 2, {true, do_write}}},
Tom Cherryb7349902015-08-26 11:43:36 -07001256 };
Tom Cherryb27004a2017-03-27 16:27:30 -07001257 // clang-format on
Tom Cherryb7349902015-08-26 11:43:36 -07001258 return builtin_functions;
1259}
Tom Cherryde6bd502018-02-13 16:50:08 -08001260// Builtin-function-map end
Tom Cherry81f5d3e2017-06-22 12:53:17 -07001261
1262} // namespace init
1263} // namespace android