blob: 35f1a9e04ce5859de7f8d186c222a65e14863e48 [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
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070019#include <errno.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070020#include <fcntl.h>
Yusuke Sato0df08272015-07-08 14:57:07 -070021#include <mntent.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070022#include <net/if.h>
Yusuke Sato0df08272015-07-08 14:57:07 -070023#include <signal.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070024#include <stdio.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070025#include <stdlib.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070026#include <string.h>
27#include <sys/socket.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070028#include <sys/mount.h>
29#include <sys/resource.h>
Elliott Hughes3d74d7a2015-01-29 21:31:23 -080030#include <sys/time.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070031#include <sys/types.h>
32#include <sys/stat.h>
Ken Sumrall0e9dd902012-04-17 17:20:16 -070033#include <sys/wait.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070034#include <unistd.h>
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +000035#include <linux/loop.h>
Paul Lawrence806d10b2015-04-28 22:07:10 +000036#include <ext4_crypt_init_extensions.h>
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070037
Stephen Smalleye46f9d52012-01-13 08:48:47 -050038#include <selinux/selinux.h>
39#include <selinux/label.h>
Stephen Smalleye46f9d52012-01-13 08:48:47 -050040
Elliott Hughesdb3f2672015-03-20 09:45:18 -070041#include <fs_mgr.h>
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -080042#include <android-base/parseint.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080043#include <android-base/stringprintf.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070044#include <cutils/partition_utils.h>
45#include <cutils/android_reboot.h>
Yusuke Sato0df08272015-07-08 14:57:07 -070046#include <logwrap/logwrap.h>
Elliott Hughesdb3f2672015-03-20 09:45:18 -070047#include <private/android_filesystem_config.h>
48
Tom Cherryfa0c21c2015-07-23 17:53:11 -070049#include "action.h"
Tom Cherryb7349902015-08-26 11:43:36 -070050#include "bootchart.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070051#include "devices.h"
Tom Cherrybac32992015-07-31 12:45:25 -070052#include "init.h"
Colin Cross6310a822010-04-20 14:29:05 -070053#include "init_parser.h"
Colin Crossed8a7d82010-04-19 17:05:34 -070054#include "log.h"
Tom Cherrybac32992015-07-31 12:45:25 -070055#include "property_service.h"
56#include "service.h"
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -080057#include "signal_handler.h"
Tom Cherrybac32992015-07-31 12:45:25 -070058#include "util.h"
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070059
Nick Kralevichbc609542015-01-31 21:39:46 -080060#define chmod DO_NOT_USE_CHMOD_USE_FCHMODAT_SYMLINK_NOFOLLOW
Yusuke Sato0df08272015-07-08 14:57:07 -070061#define UNMOUNT_CHECK_MS 5000
62#define UNMOUNT_CHECK_TIMES 10
Nick Kralevichbc609542015-01-31 21:39:46 -080063
Elliott Hughesf3cf4382015-02-03 17:12:07 -080064// System call provided by bionic but not in any header file.
65extern "C" int init_module(void *, unsigned long, const char *);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070066
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -080067static const int kTerminateServiceDelayMicroSeconds = 50000;
68
Tom Cherryb7349902015-08-26 11:43:36 -070069static int insmod(const char *filename, const char *options) {
Tom Cherryeaa3b4e2015-05-12 13:54:41 -070070 std::string module;
Yabin Cui00ede7d2015-07-24 13:26:04 -070071 if (!read_file(filename, &module)) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070072 return -1;
Elliott Hughesf682b472015-02-06 12:19:48 -080073 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070074
Elliott Hughesf682b472015-02-06 12:19:48 -080075 // TODO: use finit_module for >= 3.8 kernels.
76 return init_module(&module[0], module.size(), options);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070077}
78
Tom Cherryb7349902015-08-26 11:43:36 -070079static int __ifupdown(const char *interface, int up) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -070080 struct ifreq ifr;
81 int s, ret;
82
83 strlcpy(ifr.ifr_name, interface, IFNAMSIZ);
84
85 s = socket(AF_INET, SOCK_DGRAM, 0);
86 if (s < 0)
87 return -1;
88
89 ret = ioctl(s, SIOCGIFFLAGS, &ifr);
90 if (ret < 0) {
91 goto done;
92 }
93
94 if (up)
95 ifr.ifr_flags |= IFF_UP;
96 else
97 ifr.ifr_flags &= ~IFF_UP;
98
99 ret = ioctl(s, SIOCSIFFLAGS, &ifr);
Elliott Hughes24627902015-02-04 10:25:09 -0800100
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700101done:
102 close(s);
103 return ret;
104}
105
Tom Cherryb7349902015-08-26 11:43:36 -0700106static void unmount_and_fsck(const struct mntent *entry) {
Yusuke Sato0df08272015-07-08 14:57:07 -0700107 if (strcmp(entry->mnt_type, "f2fs") && strcmp(entry->mnt_type, "ext4"))
108 return;
109
110 /* First, lazily unmount the directory. This unmount request finishes when
111 * all processes that open a file or directory in |entry->mnt_dir| exit.
112 */
113 TEMP_FAILURE_RETRY(umount2(entry->mnt_dir, MNT_DETACH));
114
115 /* Next, kill all processes except init, kthreadd, and kthreadd's
116 * children to finish the lazy unmount. Killing all processes here is okay
117 * because this callback function is only called right before reboot().
118 * It might be cleaner to selectively kill processes that actually use
119 * |entry->mnt_dir| rather than killing all, probably by reusing a function
120 * like killProcessesWithOpenFiles() in vold/, but the selinux policy does
121 * not allow init to scan /proc/<pid> files which the utility function
122 * heavily relies on. The policy does not allow the process to execute
123 * killall/pkill binaries either. Note that some processes might
124 * automatically restart after kill(), but that is not really a problem
125 * because |entry->mnt_dir| is no longer visible to such new processes.
126 */
Tom Cherrybac32992015-07-31 12:45:25 -0700127 ServiceManager::GetInstance().ForEachService([] (Service* s) { s->Stop(); });
Yusuke Sato0df08272015-07-08 14:57:07 -0700128 TEMP_FAILURE_RETRY(kill(-1, SIGKILL));
129
130 int count = 0;
131 while (count++ < UNMOUNT_CHECK_TIMES) {
132 int fd = TEMP_FAILURE_RETRY(open(entry->mnt_fsname, O_RDONLY | O_EXCL));
133 if (fd >= 0) {
134 /* |entry->mnt_dir| has sucessfully been unmounted. */
135 close(fd);
136 break;
137 } else if (errno == EBUSY) {
138 /* Some processes using |entry->mnt_dir| are still alive. Wait for a
139 * while then retry.
140 */
141 TEMP_FAILURE_RETRY(
142 usleep(UNMOUNT_CHECK_MS * 1000 / UNMOUNT_CHECK_TIMES));
143 continue;
144 } else {
145 /* Cannot open the device. Give up. */
146 return;
147 }
148 }
149
150 int st;
151 if (!strcmp(entry->mnt_type, "f2fs")) {
152 const char *f2fs_argv[] = {
153 "/system/bin/fsck.f2fs", "-f", entry->mnt_fsname,
154 };
155 android_fork_execvp_ext(ARRAY_SIZE(f2fs_argv), (char **)f2fs_argv,
Yusuke Satod81c3c62015-08-14 01:22:53 -0700156 &st, true, LOG_KLOG, true, NULL, NULL, 0);
Yusuke Sato0df08272015-07-08 14:57:07 -0700157 } else if (!strcmp(entry->mnt_type, "ext4")) {
158 const char *ext4_argv[] = {
159 "/system/bin/e2fsck", "-f", "-y", entry->mnt_fsname,
160 };
161 android_fork_execvp_ext(ARRAY_SIZE(ext4_argv), (char **)ext4_argv,
Yusuke Satod81c3c62015-08-14 01:22:53 -0700162 &st, true, LOG_KLOG, true, NULL, NULL, 0);
Yusuke Sato0df08272015-07-08 14:57:07 -0700163 }
164}
165
Tom Cherryb7349902015-08-26 11:43:36 -0700166static int do_class_start(const std::vector<std::string>& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700167 /* Starting a class does not start services
168 * which are explicitly disabled. They must
169 * be started individually.
170 */
Tom Cherrybac32992015-07-31 12:45:25 -0700171 ServiceManager::GetInstance().
172 ForEachServiceInClass(args[1], [] (Service* s) { s->StartIfNotDisabled(); });
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700173 return 0;
174}
175
Tom Cherryb7349902015-08-26 11:43:36 -0700176static int do_class_stop(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700177 ServiceManager::GetInstance().
178 ForEachServiceInClass(args[1], [] (Service* s) { s->Stop(); });
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700179 return 0;
180}
181
Tom Cherryb7349902015-08-26 11:43:36 -0700182static int do_class_reset(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700183 ServiceManager::GetInstance().
184 ForEachServiceInClass(args[1], [] (Service* s) { s->Reset(); });
Ken Sumrall752923c2010-12-03 16:33:31 -0800185 return 0;
186}
187
Tom Cherryb7349902015-08-26 11:43:36 -0700188static int do_domainname(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700189 return write_file("/proc/sys/kernel/domainname", args[1].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700190}
191
Tom Cherryb7349902015-08-26 11:43:36 -0700192static int do_enable(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700193 Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
194 if (!svc) {
JP Abgrall3beec7e2014-05-02 21:14:29 -0700195 return -1;
196 }
Tom Cherrybac32992015-07-31 12:45:25 -0700197 return svc->Enable();
JP Abgrall3beec7e2014-05-02 21:14:29 -0700198}
199
Tom Cherryb7349902015-08-26 11:43:36 -0700200static int do_exec(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700201 Service* svc = ServiceManager::GetInstance().MakeExecOneshotService(args);
202 if (!svc) {
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800203 return -1;
204 }
Tom Cherrybac32992015-07-31 12:45:25 -0700205 if (!svc->Start()) {
206 return -1;
207 }
208 waiting_for_exec = true;
Elliott Hughes8d82ea02015-02-06 20:15:18 -0800209 return 0;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700210}
211
Tom Cherryb7349902015-08-26 11:43:36 -0700212static int do_export(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700213 return add_environment(args[1].c_str(), args[2].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700214}
215
Tom Cherryb7349902015-08-26 11:43:36 -0700216static int do_hostname(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700217 return write_file("/proc/sys/kernel/hostname", args[1].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700218}
219
Tom Cherryb7349902015-08-26 11:43:36 -0700220static int do_ifup(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700221 return __ifupdown(args[1].c_str(), 1);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700222}
223
Tom Cherryb7349902015-08-26 11:43:36 -0700224static int do_insmod(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700225 std::string options;
The Android Open Source Project35237d12008-12-17 18:08:08 -0800226
Tom Cherry96f67312015-07-30 13:52:55 -0700227 if (args.size() > 2) {
228 options += args[2];
229 for (std::size_t i = 3; i < args.size(); ++i) {
230 options += ' ';
231 options += args[i];
The Android Open Source Project35237d12008-12-17 18:08:08 -0800232 }
233 }
234
Tom Cherry96f67312015-07-30 13:52:55 -0700235 return insmod(args[1].c_str(), options.c_str());
The Android Open Source Project35237d12008-12-17 18:08:08 -0800236}
237
Tom Cherryb7349902015-08-26 11:43:36 -0700238static int do_mkdir(const std::vector<std::string>& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700239 mode_t mode = 0755;
Chia-chi Yeh27164dc2011-07-08 12:57:36 -0700240 int ret;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700241
242 /* mkdir <path> [mode] [owner] [group] */
243
Tom Cherry96f67312015-07-30 13:52:55 -0700244 if (args.size() >= 3) {
245 mode = std::stoul(args[2], 0, 8);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700246 }
247
Tom Cherry96f67312015-07-30 13:52:55 -0700248 ret = make_dir(args[1].c_str(), mode);
Chia-chi Yeh27164dc2011-07-08 12:57:36 -0700249 /* chmod in case the directory already exists */
250 if (ret == -1 && errno == EEXIST) {
Tom Cherry96f67312015-07-30 13:52:55 -0700251 ret = fchmodat(AT_FDCWD, args[1].c_str(), mode, AT_SYMLINK_NOFOLLOW);
Chia-chi Yeh27164dc2011-07-08 12:57:36 -0700252 }
253 if (ret == -1) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700254 return -errno;
255 }
256
Tom Cherry96f67312015-07-30 13:52:55 -0700257 if (args.size() >= 4) {
258 uid_t uid = decode_uid(args[3].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700259 gid_t gid = -1;
260
Tom Cherry96f67312015-07-30 13:52:55 -0700261 if (args.size() == 5) {
262 gid = decode_uid(args[4].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700263 }
264
Tom Cherry96f67312015-07-30 13:52:55 -0700265 if (lchown(args[1].c_str(), uid, gid) == -1) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700266 return -errno;
267 }
Benoit Goby5c8574b2012-08-14 15:43:46 -0700268
269 /* chown may have cleared S_ISUID and S_ISGID, chmod again */
270 if (mode & (S_ISUID | S_ISGID)) {
Tom Cherry96f67312015-07-30 13:52:55 -0700271 ret = fchmodat(AT_FDCWD, args[1].c_str(), mode, AT_SYMLINK_NOFOLLOW);
Benoit Goby5c8574b2012-08-14 15:43:46 -0700272 if (ret == -1) {
273 return -errno;
274 }
275 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700276 }
277
Tom Cherry96f67312015-07-30 13:52:55 -0700278 return e4crypt_set_directory_policy(args[1].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700279}
280
281static struct {
282 const char *name;
283 unsigned flag;
284} mount_flags[] = {
285 { "noatime", MS_NOATIME },
Lars Svenssonb6ee25e2011-07-14 13:39:09 +0200286 { "noexec", MS_NOEXEC },
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700287 { "nosuid", MS_NOSUID },
288 { "nodev", MS_NODEV },
289 { "nodiratime", MS_NODIRATIME },
290 { "ro", MS_RDONLY },
291 { "rw", 0 },
292 { "remount", MS_REMOUNT },
Jeff Sharkeye50ac5f2012-08-14 11:34:34 -0700293 { "bind", MS_BIND },
294 { "rec", MS_REC },
295 { "unbindable", MS_UNBINDABLE },
296 { "private", MS_PRIVATE },
297 { "slave", MS_SLAVE },
298 { "shared", MS_SHARED },
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700299 { "defaults", 0 },
300 { 0, 0 },
301};
302
Ken Sumrall752923c2010-12-03 16:33:31 -0800303#define DATA_MNT_POINT "/data"
304
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700305/* mount <type> <device> <path> <flags ...> <options> */
Tom Cherryb7349902015-08-26 11:43:36 -0700306static int do_mount(const std::vector<std::string>& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700307 char tmp[64];
Tom Cherry96f67312015-07-30 13:52:55 -0700308 const char *source, *target, *system;
309 const char *options = NULL;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700310 unsigned flags = 0;
Tom Cherry96f67312015-07-30 13:52:55 -0700311 std::size_t na = 0;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700312 int n, i;
Colin Crosscd0f1732010-04-19 17:10:24 -0700313 int wait = 0;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700314
Tom Cherry96f67312015-07-30 13:52:55 -0700315 for (na = 4; na < args.size(); na++) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700316 for (i = 0; mount_flags[i].name; i++) {
Tom Cherry96f67312015-07-30 13:52:55 -0700317 if (!args[na].compare(mount_flags[i].name)) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700318 flags |= mount_flags[i].flag;
319 break;
320 }
321 }
322
Colin Crosscd0f1732010-04-19 17:10:24 -0700323 if (!mount_flags[i].name) {
Tom Cherry96f67312015-07-30 13:52:55 -0700324 if (!args[na].compare("wait"))
Colin Crosscd0f1732010-04-19 17:10:24 -0700325 wait = 1;
326 /* if our last argument isn't a flag, wolf it up as an option string */
Tom Cherry96f67312015-07-30 13:52:55 -0700327 else if (na + 1 == args.size())
328 options = args[na].c_str();
Colin Crosscd0f1732010-04-19 17:10:24 -0700329 }
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700330 }
331
Tom Cherry96f67312015-07-30 13:52:55 -0700332 system = args[1].c_str();
333 source = args[2].c_str();
334 target = args[3].c_str();
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000335
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700336 if (!strncmp(source, "mtd@", 4)) {
337 n = mtd_name_to_number(source + 4);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000338 if (n < 0) {
339 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700340 }
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000341
Yabin Cuie2d63af2015-02-17 19:27:51 -0800342 snprintf(tmp, sizeof(tmp), "/dev/block/mtdblock%d", n);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000343
Colin Crosscd0f1732010-04-19 17:10:24 -0700344 if (wait)
345 wait_for_file(tmp, COMMAND_RETRY_TIMEOUT);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000346 if (mount(tmp, target, system, flags, options) < 0) {
347 return -1;
348 }
349
Ken Sumralldd4d7862011-02-17 18:09:47 -0800350 goto exit_success;
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000351 } else if (!strncmp(source, "loop@", 5)) {
352 int mode, loop, fd;
353 struct loop_info info;
354
355 mode = (flags & MS_RDONLY) ? O_RDONLY : O_RDWR;
Nick Kralevich45a884f2015-02-02 14:37:22 -0800356 fd = open(source + 5, mode | O_CLOEXEC);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000357 if (fd < 0) {
358 return -1;
359 }
360
361 for (n = 0; ; n++) {
Yabin Cuie2d63af2015-02-17 19:27:51 -0800362 snprintf(tmp, sizeof(tmp), "/dev/block/loop%d", n);
Nick Kralevich45a884f2015-02-02 14:37:22 -0800363 loop = open(tmp, mode | O_CLOEXEC);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000364 if (loop < 0) {
Tomasz Kondelbfdcc402014-02-06 08:57:27 +0100365 close(fd);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000366 return -1;
367 }
368
369 /* if it is a blank loop device */
370 if (ioctl(loop, LOOP_GET_STATUS, &info) < 0 && errno == ENXIO) {
371 /* if it becomes our loop device */
372 if (ioctl(loop, LOOP_SET_FD, fd) >= 0) {
373 close(fd);
374
375 if (mount(tmp, target, system, flags, options) < 0) {
376 ioctl(loop, LOOP_CLR_FD, 0);
377 close(loop);
378 return -1;
379 }
380
381 close(loop);
Ken Sumralldd4d7862011-02-17 18:09:47 -0800382 goto exit_success;
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000383 }
384 }
385
386 close(loop);
387 }
388
389 close(fd);
390 ERROR("out of loopback devices");
391 return -1;
392 } else {
Colin Crosscd0f1732010-04-19 17:10:24 -0700393 if (wait)
394 wait_for_file(source, COMMAND_RETRY_TIMEOUT);
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000395 if (mount(source, target, system, flags, options) < 0) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700396 return -1;
Jay Freeman (saurik)e520d032008-11-20 03:37:30 +0000397 }
398
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700399 }
Ken Sumralldd4d7862011-02-17 18:09:47 -0800400
401exit_success:
Ken Sumralldd4d7862011-02-17 18:09:47 -0800402 return 0;
403
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700404}
405
Tom Cherryb7349902015-08-26 11:43:36 -0700406static int wipe_data_via_recovery() {
JP Abgrallcee20682014-07-02 14:26:54 -0700407 mkdir("/cache/recovery", 0700);
Nick Kralevich45a884f2015-02-02 14:37:22 -0800408 int fd = open("/cache/recovery/command", O_RDWR|O_CREAT|O_TRUNC|O_CLOEXEC, 0600);
JP Abgrallcee20682014-07-02 14:26:54 -0700409 if (fd >= 0) {
Jeff Sharkeyd26135b2014-09-24 11:46:36 -0700410 write(fd, "--wipe_data\n", strlen("--wipe_data\n") + 1);
411 write(fd, "--reason=wipe_data_via_recovery\n", strlen("--reason=wipe_data_via_recovery\n") + 1);
JP Abgrallcee20682014-07-02 14:26:54 -0700412 close(fd);
413 } else {
414 ERROR("could not open /cache/recovery/command\n");
415 return -1;
416 }
417 android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
418 while (1) { pause(); } // never reached
419}
420
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800421/* Imports .rc files from the specified paths. Default ones are applied if none is given.
422 *
423 * start_index: index of the first path in the args list
424 */
425static void import_late(const std::vector<std::string>& args, size_t start_index) {
Tom Cherryb7349902015-08-26 11:43:36 -0700426 Parser& parser = Parser::GetInstance();
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800427 if (args.size() <= start_index) {
428 // Use the default set if no path is given
429 static const std::vector<std::string> init_directories = {
430 "/system/etc/init",
431 "/vendor/etc/init",
432 "/odm/etc/init"
433 };
434
435 for (const auto& dir : init_directories) {
436 parser.ParseConfig(dir);
437 }
438 } else {
439 for (size_t i = start_index; i < args.size(); ++i) {
440 parser.ParseConfig(args[i]);
441 }
Tom Cherryb8dd0272015-07-22 14:23:33 -0700442 }
443}
444
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800445/* mount_all <fstab> [ <path> ]*
446 *
JP Abgrallcee20682014-07-02 14:26:54 -0700447 * This function might request a reboot, in which case it will
448 * not return.
449 */
Tom Cherryb7349902015-08-26 11:43:36 -0700450static int do_mount_all(const std::vector<std::string>& args) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700451 pid_t pid;
452 int ret = -1;
453 int child_ret = -1;
454 int status;
Ken Sumrallab6b8522013-02-13 12:58:40 -0800455 struct fstab *fstab;
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700456
Tom Cherry96f67312015-07-30 13:52:55 -0700457 const char* fstabfile = args[1].c_str();
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700458 /*
459 * Call fs_mgr_mount_all() to mount all filesystems. We fork(2) and
460 * do the call in the child to provide protection to the main init
461 * process if anything goes wrong (crash or memory leak), and wait for
462 * the child to finish in the parent.
463 */
464 pid = fork();
465 if (pid > 0) {
466 /* Parent. Wait for the child to return */
Paul Lawrence40af0922014-09-16 14:31:23 -0700467 int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
468 if (wp_ret < 0) {
469 /* Unexpected error code. We will continue anyway. */
Elliott Hughescd67f002015-03-20 17:05:56 -0700470 NOTICE("waitpid failed rc=%d: %s\n", wp_ret, strerror(errno));
Paul Lawrence40af0922014-09-16 14:31:23 -0700471 }
472
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700473 if (WIFEXITED(status)) {
474 ret = WEXITSTATUS(status);
475 } else {
476 ret = -1;
477 }
478 } else if (pid == 0) {
479 /* child, call fs_mgr_mount_all() */
480 klog_set_level(6); /* So we can see what fs_mgr_mount_all() does */
Nan Liu12df1e12015-07-21 19:44:07 +0800481 fstab = fs_mgr_read_fstab(fstabfile);
Ken Sumrallab6b8522013-02-13 12:58:40 -0800482 child_ret = fs_mgr_mount_all(fstab);
483 fs_mgr_free_fstab(fstab);
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700484 if (child_ret == -1) {
485 ERROR("fs_mgr_mount_all returned an error\n");
486 }
JP Abgrallf22b7452014-07-02 13:16:04 -0700487 _exit(child_ret);
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700488 } else {
489 /* fork failed, return an error */
490 return -1;
491 }
492
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800493 /* Paths of .rc files are specified at the 2nd argument and beyond */
494 import_late(args, 2);
Tom Cherryb8dd0272015-07-22 14:23:33 -0700495
JP Abgrallf22b7452014-07-02 13:16:04 -0700496 if (ret == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
Paul Lawrence166fa3d2014-02-03 13:27:49 -0800497 property_set("vold.decrypt", "trigger_encryption");
JP Abgrallf22b7452014-07-02 13:16:04 -0700498 } else if (ret == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700499 property_set("ro.crypto.state", "encrypted");
Paul Lawrence806d10b2015-04-28 22:07:10 +0000500 property_set("ro.crypto.type", "block");
Paul Lawrence13d5bb42014-01-30 10:43:52 -0800501 property_set("vold.decrypt", "trigger_default_encryption");
JP Abgrallf22b7452014-07-02 13:16:04 -0700502 } else if (ret == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700503 property_set("ro.crypto.state", "unencrypted");
504 /* If fs_mgr determined this is an unencrypted device, then trigger
505 * that action.
506 */
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700507 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
JP Abgrallcee20682014-07-02 14:26:54 -0700508 } else if (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
509 /* Setup a wipe via recovery, and reboot into recovery */
510 ERROR("fs_mgr_mount_all suggested recovery, so wiping data via recovery.\n");
511 ret = wipe_data_via_recovery();
512 /* If reboot worked, there is no return. */
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000513 } else if (ret == FS_MGR_MNTALL_DEV_DEFAULT_FILE_ENCRYPTED) {
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000514 if (e4crypt_install_keyring()) {
515 return -1;
516 }
517 property_set("ro.crypto.state", "encrypted");
Paul Lawrence806d10b2015-04-28 22:07:10 +0000518 property_set("ro.crypto.type", "file");
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000519
520 // Although encrypted, we have device key, so we do not need to
521 // do anything different from the nonencrypted case.
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700522 ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000523 } else if (ret == FS_MGR_MNTALL_DEV_NON_DEFAULT_FILE_ENCRYPTED) {
524 if (e4crypt_install_keyring()) {
525 return -1;
526 }
527 property_set("ro.crypto.state", "encrypted");
Paul Lawrence806d10b2015-04-28 22:07:10 +0000528 property_set("ro.crypto.type", "file");
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000529 property_set("vold.decrypt", "trigger_restart_min_framework");
JP Abgrallcee20682014-07-02 14:26:54 -0700530 } else if (ret > 0) {
531 ERROR("fs_mgr_mount_all returned unexpected error %d\n", ret);
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700532 }
JP Abgrallf22b7452014-07-02 13:16:04 -0700533 /* else ... < 0: error */
Ken Sumrall0e9dd902012-04-17 17:20:16 -0700534
535 return ret;
536}
537
Tom Cherryb7349902015-08-26 11:43:36 -0700538static int do_swapon_all(const std::vector<std::string>& args) {
Ken Sumralla76baaa2013-07-09 18:42:09 -0700539 struct fstab *fstab;
540 int ret;
541
Tom Cherry96f67312015-07-30 13:52:55 -0700542 fstab = fs_mgr_read_fstab(args[1].c_str());
Ken Sumralla76baaa2013-07-09 18:42:09 -0700543 ret = fs_mgr_swapon_all(fstab);
544 fs_mgr_free_fstab(fstab);
545
546 return ret;
547}
548
Tom Cherryb7349902015-08-26 11:43:36 -0700549static int do_setprop(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700550 const char* name = args[1].c_str();
551 const char* value = args[2].c_str();
Yabin Cui00ede7d2015-07-24 13:26:04 -0700552 property_set(name, value);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700553 return 0;
554}
555
Tom Cherryb7349902015-08-26 11:43:36 -0700556static int do_setrlimit(const std::vector<std::string>& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700557 struct rlimit limit;
558 int resource;
Tom Cherry96f67312015-07-30 13:52:55 -0700559 resource = std::stoi(args[1]);
560 limit.rlim_cur = std::stoi(args[2]);
561 limit.rlim_max = std::stoi(args[3]);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700562 return setrlimit(resource, &limit);
563}
564
Tom Cherryb7349902015-08-26 11:43:36 -0700565static int do_start(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700566 Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
567 if (!svc) {
568 ERROR("do_start: Service %s not found\n", args[1].c_str());
569 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700570 }
Tom Cherrybac32992015-07-31 12:45:25 -0700571 if (!svc->Start())
572 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700573 return 0;
574}
575
Tom Cherryb7349902015-08-26 11:43:36 -0700576static int do_stop(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700577 Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
578 if (!svc) {
579 ERROR("do_stop: Service %s not found\n", args[1].c_str());
580 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700581 }
Tom Cherrybac32992015-07-31 12:45:25 -0700582 svc->Stop();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700583 return 0;
584}
585
Tom Cherryb7349902015-08-26 11:43:36 -0700586static int do_restart(const std::vector<std::string>& args) {
Tom Cherrybac32992015-07-31 12:45:25 -0700587 Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
588 if (!svc) {
589 ERROR("do_restart: Service %s not found\n", args[1].c_str());
590 return -1;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700591 }
Tom Cherrybac32992015-07-31 12:45:25 -0700592 svc->Restart();
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700593 return 0;
594}
595
Tom Cherryb7349902015-08-26 11:43:36 -0700596static int do_powerctl(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700597 const char* command = args[1].c_str();
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700598 int len = 0;
Yusuke Satof93d4292015-07-21 15:50:59 -0700599 unsigned int cmd = 0;
600 const char *reboot_target = "";
Yusuke Sato0df08272015-07-08 14:57:07 -0700601 void (*callback_on_ro_remount)(const struct mntent*) = NULL;
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700602
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700603 if (strncmp(command, "shutdown", 8) == 0) {
604 cmd = ANDROID_RB_POWEROFF;
605 len = 8;
606 } else if (strncmp(command, "reboot", 6) == 0) {
607 cmd = ANDROID_RB_RESTART2;
608 len = 6;
609 } else {
610 ERROR("powerctl: unrecognized command '%s'\n", command);
611 return -EINVAL;
612 }
613
614 if (command[len] == ',') {
Yusuke Satof93d4292015-07-21 15:50:59 -0700615 if (cmd == ANDROID_RB_POWEROFF &&
616 !strcmp(&command[len + 1], "userrequested")) {
617 // The shutdown reason is PowerManager.SHUTDOWN_USER_REQUESTED.
618 // Run fsck once the file system is remounted in read-only mode.
619 callback_on_ro_remount = unmount_and_fsck;
620 } else if (cmd == ANDROID_RB_RESTART2) {
621 reboot_target = &command[len + 1];
622 }
623 } else if (command[len] != '\0') {
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700624 ERROR("powerctl: unrecognized reboot target '%s'\n", &command[len]);
625 return -EINVAL;
626 }
627
Bertrand SIMONNETb7e03e82015-12-18 11:39:59 -0800628 std::string timeout = property_get("ro.build.shutdown_timeout");
629 unsigned int delay = 0;
630
631 if (android::base::ParseUint(timeout.c_str(), &delay) && delay > 0) {
632 Timer t;
633 // Ask all services to terminate.
634 ServiceManager::GetInstance().ForEachService(
635 [] (Service* s) { s->Terminate(); });
636
637 while (t.duration() < delay) {
638 ServiceManager::GetInstance().ReapAnyOutstandingChildren();
639
640 int service_count = 0;
641 ServiceManager::GetInstance().ForEachService(
642 [&service_count] (Service* s) {
643 // Count the number of services running.
644 // Exclude the console as it will ignore the SIGTERM signal
645 // and not exit.
646 // Note: SVC_CONSOLE actually means "requires console" but
647 // it is only used by the shell.
648 if (s->pid() != 0 && (s->flags() & SVC_CONSOLE) == 0) {
649 service_count++;
650 }
651 });
652
653 if (service_count == 0) {
654 // All terminable services terminated. We can exit early.
655 break;
656 }
657
658 // Wait a bit before recounting the number or running services.
659 usleep(kTerminateServiceDelayMicroSeconds);
660 }
661 NOTICE("Terminating running services took %.02f seconds", t.duration());
662 }
663
Yusuke Sato0df08272015-07-08 14:57:07 -0700664 return android_reboot_with_callback(cmd, 0, reboot_target,
665 callback_on_ro_remount);
Nick Kralevichca8e66a2013-04-18 12:20:02 -0700666}
667
Tom Cherryb7349902015-08-26 11:43:36 -0700668static int do_trigger(const std::vector<std::string>& args) {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700669 ActionManager::GetInstance().QueueEventTrigger(args[1]);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700670 return 0;
671}
672
Tom Cherryb7349902015-08-26 11:43:36 -0700673static int do_symlink(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700674 return symlink(args[1].c_str(), args[2].c_str());
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700675}
676
Tom Cherryb7349902015-08-26 11:43:36 -0700677static int do_rm(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700678 return unlink(args[1].c_str());
Ken Sumrall203bad52011-01-18 17:37:41 -0800679}
680
Tom Cherryb7349902015-08-26 11:43:36 -0700681static int do_rmdir(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700682 return rmdir(args[1].c_str());
Ken Sumrall203bad52011-01-18 17:37:41 -0800683}
684
Tom Cherryb7349902015-08-26 11:43:36 -0700685static int do_sysclktz(const std::vector<std::string>& args) {
The Android Open Source Project35237d12008-12-17 18:08:08 -0800686 struct timezone tz;
687
The Android Open Source Project35237d12008-12-17 18:08:08 -0800688 memset(&tz, 0, sizeof(tz));
Tom Cherry96f67312015-07-30 13:52:55 -0700689 tz.tz_minuteswest = std::stoi(args[1]);
The Android Open Source Project35237d12008-12-17 18:08:08 -0800690 if (settimeofday(NULL, &tz))
691 return -1;
692 return 0;
693}
694
Tom Cherryb7349902015-08-26 11:43:36 -0700695static int do_verity_load_state(const std::vector<std::string>& args) {
Elliott Hughesdb3f2672015-03-20 09:45:18 -0700696 int mode = -1;
697 int rc = fs_mgr_load_verity_state(&mode);
Sami Tolvanen90f52df2015-12-02 14:23:09 +0000698 if (rc == 0 && mode != VERITY_MODE_DEFAULT) {
Tom Cherryfa0c21c2015-07-23 17:53:11 -0700699 ActionManager::GetInstance().QueueEventTrigger("verity-logging");
Sami Tolvanen8ff01902015-02-16 11:03:34 +0000700 }
Elliott Hughesdb3f2672015-03-20 09:45:18 -0700701 return rc;
Sami Tolvanen8ff01902015-02-16 11:03:34 +0000702}
703
Tom Cherryb7349902015-08-26 11:43:36 -0700704static void verity_update_property(fstab_rec *fstab, const char *mount_point,
705 int mode, int status) {
Sami Tolvanen45474232015-03-30 11:38:38 +0100706 property_set(android::base::StringPrintf("partition.%s.verified", mount_point).c_str(),
707 android::base::StringPrintf("%d", mode).c_str());
Sami Tolvanenacbf9be2015-03-19 10:00:34 +0000708}
709
Tom Cherryb7349902015-08-26 11:43:36 -0700710static int do_verity_update_state(const std::vector<std::string>& args) {
Elliott Hughesdb3f2672015-03-20 09:45:18 -0700711 return fs_mgr_update_verity_state(verity_update_property);
Sami Tolvanenacbf9be2015-03-19 10:00:34 +0000712}
713
Tom Cherryb7349902015-08-26 11:43:36 -0700714static int do_write(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700715 const char* path = args[1].c_str();
716 const char* value = args[2].c_str();
Yabin Cui00ede7d2015-07-24 13:26:04 -0700717 return write_file(path, value);
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700718}
719
Tom Cherryb7349902015-08-26 11:43:36 -0700720static int do_copy(const std::vector<std::string>& args) {
San Mehat7c44fe52009-08-26 16:39:25 -0700721 char *buffer = NULL;
722 int rc = 0;
723 int fd1 = -1, fd2 = -1;
724 struct stat info;
725 int brtw, brtr;
726 char *p;
727
Tom Cherry96f67312015-07-30 13:52:55 -0700728 if (stat(args[1].c_str(), &info) < 0)
San Mehat7c44fe52009-08-26 16:39:25 -0700729 return -1;
730
Tom Cherry96f67312015-07-30 13:52:55 -0700731 if ((fd1 = open(args[1].c_str(), O_RDONLY|O_CLOEXEC)) < 0)
San Mehat7c44fe52009-08-26 16:39:25 -0700732 goto out_err;
733
Tom Cherry96f67312015-07-30 13:52:55 -0700734 if ((fd2 = open(args[2].c_str(), O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0660)) < 0)
San Mehat7c44fe52009-08-26 16:39:25 -0700735 goto out_err;
736
Elliott Hughesf3cf4382015-02-03 17:12:07 -0800737 if (!(buffer = (char*) malloc(info.st_size)))
San Mehat7c44fe52009-08-26 16:39:25 -0700738 goto out_err;
739
740 p = buffer;
741 brtr = info.st_size;
742 while(brtr) {
743 rc = read(fd1, p, brtr);
744 if (rc < 0)
745 goto out_err;
746 if (rc == 0)
747 break;
748 p += rc;
749 brtr -= rc;
750 }
751
752 p = buffer;
753 brtw = info.st_size;
754 while(brtw) {
755 rc = write(fd2, p, brtw);
756 if (rc < 0)
757 goto out_err;
758 if (rc == 0)
759 break;
760 p += rc;
761 brtw -= rc;
762 }
763
764 rc = 0;
765 goto out;
766out_err:
767 rc = -1;
768out:
769 if (buffer)
770 free(buffer);
771 if (fd1 >= 0)
772 close(fd1);
773 if (fd2 >= 0)
774 close(fd2);
775 return rc;
776}
777
Tom Cherryb7349902015-08-26 11:43:36 -0700778static int do_chown(const std::vector<std::string>& args) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700779 /* GID is optional. */
Tom Cherry96f67312015-07-30 13:52:55 -0700780 if (args.size() == 3) {
781 if (lchown(args[2].c_str(), decode_uid(args[1].c_str()), -1) == -1)
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700782 return -errno;
Tom Cherry96f67312015-07-30 13:52:55 -0700783 } else if (args.size() == 4) {
784 if (lchown(args[3].c_str(), decode_uid(args[1].c_str()),
785 decode_uid(args[2].c_str())) == -1)
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700786 return -errno;
787 } else {
788 return -1;
789 }
790 return 0;
791}
792
793static mode_t get_mode(const char *s) {
794 mode_t mode = 0;
795 while (*s) {
796 if (*s >= '0' && *s <= '7') {
797 mode = (mode<<3) | (*s-'0');
798 } else {
799 return -1;
800 }
801 s++;
802 }
803 return mode;
804}
805
Tom Cherryb7349902015-08-26 11:43:36 -0700806static int do_chmod(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700807 mode_t mode = get_mode(args[1].c_str());
808 if (fchmodat(AT_FDCWD, args[2].c_str(), mode, AT_SYMLINK_NOFOLLOW) < 0) {
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700809 return -errno;
810 }
811 return 0;
812}
813
Tom Cherryb7349902015-08-26 11:43:36 -0700814static int do_restorecon(const std::vector<std::string>& args) {
Stephen Smalley726e8f72013-10-09 16:02:09 -0400815 int ret = 0;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500816
Tom Cherry96f67312015-07-30 13:52:55 -0700817 for (auto it = std::next(args.begin()); it != args.end(); ++it) {
818 if (restorecon(it->c_str()) < 0)
Stephen Smalley726e8f72013-10-09 16:02:09 -0400819 ret = -errno;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500820 }
Stephen Smalley726e8f72013-10-09 16:02:09 -0400821 return ret;
822}
823
Tom Cherryb7349902015-08-26 11:43:36 -0700824static int do_restorecon_recursive(const std::vector<std::string>& args) {
Stephen Smalley726e8f72013-10-09 16:02:09 -0400825 int ret = 0;
826
Tom Cherry96f67312015-07-30 13:52:55 -0700827 for (auto it = std::next(args.begin()); it != args.end(); ++it) {
828 if (restorecon_recursive(it->c_str()) < 0)
Stephen Smalley726e8f72013-10-09 16:02:09 -0400829 ret = -errno;
830 }
831 return ret;
Stephen Smalleye46f9d52012-01-13 08:48:47 -0500832}
833
Tom Cherryb7349902015-08-26 11:43:36 -0700834static int do_loglevel(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700835 int log_level = std::stoi(args[1]);
Riley Andrews1bbef882014-06-26 13:55:03 -0700836 if (log_level < KLOG_ERROR_LEVEL || log_level > KLOG_DEBUG_LEVEL) {
837 ERROR("loglevel: invalid log level'%d'\n", log_level);
838 return -EINVAL;
839 }
840 klog_set_level(log_level);
841 return 0;
The Android Open Source Project4f6e8d72008-10-21 07:00:00 -0700842}
843
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700844static int do_load_persist_props(const std::vector<std::string>& args) {
Tom Cherryb7349902015-08-26 11:43:36 -0700845 load_persist_props();
846 return 0;
Ken Sumrallc5c51032011-03-08 17:01:29 -0800847}
848
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700849static int do_load_system_props(const std::vector<std::string>& args) {
850 load_system_props();
Tom Cherryb7349902015-08-26 11:43:36 -0700851 return 0;
Riley Andrewse4b7b292014-06-16 15:06:21 -0700852}
853
Tom Cherryb7349902015-08-26 11:43:36 -0700854static int do_wait(const std::vector<std::string>& args) {
Tom Cherry96f67312015-07-30 13:52:55 -0700855 if (args.size() == 2) {
856 return wait_for_file(args[1].c_str(), COMMAND_RETRY_TIMEOUT);
857 } else if (args.size() == 3) {
858 return wait_for_file(args[1].c_str(), std::stoi(args[2]));
Patrick McCormick96d0a4d2011-02-04 10:51:39 -0800859 } else
860 return -1;
Colin Crosscd0f1732010-04-19 17:10:24 -0700861}
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000862
Paul Lawrence806d10b2015-04-28 22:07:10 +0000863/*
864 * Callback to make a directory from the ext4 code
865 */
Tom Cherryb7349902015-08-26 11:43:36 -0700866static int do_installkeys_ensure_dir_exists(const char* dir) {
Paul Lawrence806d10b2015-04-28 22:07:10 +0000867 if (make_dir(dir, 0700) && errno != EEXIST) {
868 return -1;
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000869 }
870
Paul Lawrence806d10b2015-04-28 22:07:10 +0000871 return 0;
872}
873
Paul Crowley749af8c2015-05-28 17:35:06 +0100874static bool is_file_crypto() {
Yabin Cui0ff85902015-07-24 13:58:03 -0700875 std::string value = property_get("ro.crypto.type");
876 return value == "file";
Paul Crowley749af8c2015-05-28 17:35:06 +0100877}
878
Tom Cherryb7349902015-08-26 11:43:36 -0700879static int do_installkey(const std::vector<std::string>& args) {
Paul Crowley749af8c2015-05-28 17:35:06 +0100880 if (!is_file_crypto()) {
Paul Lawrence806d10b2015-04-28 22:07:10 +0000881 return 0;
882 }
Tom Cherry96f67312015-07-30 13:52:55 -0700883 return e4crypt_create_device_key(args[1].c_str(),
Paul Lawrence806d10b2015-04-28 22:07:10 +0000884 do_installkeys_ensure_dir_exists);
Paul Lawrenceb8c9d272015-03-26 15:49:42 +0000885}
Paul Crowley749af8c2015-05-28 17:35:06 +0100886
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700887static int do_setusercryptopolicies(const std::vector<std::string>& args) {
Paul Crowley749af8c2015-05-28 17:35:06 +0100888 if (!is_file_crypto()) {
889 return 0;
890 }
Tom Cherry087cd352015-08-03 14:19:35 -0700891 return e4crypt_set_user_crypto_policies(args[1].c_str());
Paul Crowley749af8c2015-05-28 17:35:06 +0100892}
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700893
Tom Cherryb7349902015-08-26 11:43:36 -0700894BuiltinFunctionMap::Map& BuiltinFunctionMap::map() const {
895 constexpr std::size_t kMax = std::numeric_limits<std::size_t>::max();
896 static const Map builtin_functions = {
897 {"bootchart_init", {0, 0, do_bootchart_init}},
898 {"chmod", {2, 2, do_chmod}},
899 {"chown", {2, 3, do_chown}},
900 {"class_reset", {1, 1, do_class_reset}},
901 {"class_start", {1, 1, do_class_start}},
902 {"class_stop", {1, 1, do_class_stop}},
903 {"copy", {2, 2, do_copy}},
904 {"domainname", {1, 1, do_domainname}},
905 {"enable", {1, 1, do_enable}},
906 {"exec", {1, kMax, do_exec}},
907 {"export", {2, 2, do_export}},
908 {"hostname", {1, 1, do_hostname}},
909 {"ifup", {1, 1, do_ifup}},
910 {"insmod", {1, kMax, do_insmod}},
911 {"installkey", {1, 1, do_installkey}},
Tom Cherryb7349902015-08-26 11:43:36 -0700912 {"load_persist_props", {0, 0, do_load_persist_props}},
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700913 {"load_system_props", {0, 0, do_load_system_props}},
Tom Cherryb7349902015-08-26 11:43:36 -0700914 {"loglevel", {1, 1, do_loglevel}},
915 {"mkdir", {1, 4, do_mkdir}},
Hung-ying Tyandc738ea2016-01-14 11:18:21 +0800916 {"mount_all", {1, kMax, do_mount_all}},
Tom Cherryb7349902015-08-26 11:43:36 -0700917 {"mount", {3, kMax, do_mount}},
918 {"powerctl", {1, 1, do_powerctl}},
919 {"restart", {1, 1, do_restart}},
920 {"restorecon", {1, kMax, do_restorecon}},
921 {"restorecon_recursive", {1, kMax, do_restorecon_recursive}},
922 {"rm", {1, 1, do_rm}},
923 {"rmdir", {1, 1, do_rmdir}},
924 {"setprop", {2, 2, do_setprop}},
925 {"setrlimit", {3, 3, do_setrlimit}},
Tom Cherryaf20a7c2015-09-01 15:05:34 -0700926 {"setusercryptopolicies", {1, 1, do_setusercryptopolicies}},
Tom Cherryb7349902015-08-26 11:43:36 -0700927 {"start", {1, 1, do_start}},
928 {"stop", {1, 1, do_stop}},
929 {"swapon_all", {1, 1, do_swapon_all}},
930 {"symlink", {2, 2, do_symlink}},
931 {"sysclktz", {1, 1, do_sysclktz}},
932 {"trigger", {1, 1, do_trigger}},
933 {"verity_load_state", {0, 0, do_verity_load_state}},
934 {"verity_update_state", {0, 0, do_verity_update_state}},
935 {"wait", {1, 2, do_wait}},
936 {"write", {2, 2, do_write}},
937 };
938 return builtin_functions;
939}