blob: e1f84042bc3dbfc2b4fa004ea330b23b49cf61b3 [file] [log] [blame]
San Mehatf1b736b2009-10-10 17:22:08 -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
Jeff Sharkey67b8c492017-09-21 17:08:43 -060017#define ATRACE_TAG ATRACE_TAG_PACKAGE_MANAGER
18
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070019#include "NetlinkManager.h"
Jeff Sharkey068c6be2017-09-06 13:47:40 -060020#include "VoldNativeService.h"
Paul Crowleye2ee1522017-09-26 14:05:26 -070021#include "VoldUtil.h"
Paul Crowley14c8c072018-09-18 13:30:21 -070022#include "VolumeManager.h"
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070023#include "cryptfs.h"
Paul Crowley14c8c072018-09-18 13:30:21 -070024#include "model/Disk.h"
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070025#include "sehandle.h"
26
Elliott Hughes7e128fb2015-12-04 15:50:53 -080027#include <android-base/logging.h>
Jeff Sharkey3472e522017-10-06 18:02:53 -060028#include <android-base/properties.h>
Elliott Hughes7e128fb2015-12-04 15:50:53 -080029#include <android-base/stringprintf.h>
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070030#include <cutils/klog.h>
Yifan Hong024a1242018-08-10 13:50:46 -070031#include <hidl/HidlTransportSupport.h>
Jeff Sharkey67b8c492017-09-21 17:08:43 -060032#include <utils/Trace.h>
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070033
Paul Crowley14c8c072018-09-18 13:30:21 -070034#include <dirent.h>
35#include <errno.h>
36#include <fcntl.h>
37#include <fs_mgr.h>
38#include <getopt.h>
San Mehatf1b736b2009-10-10 17:22:08 -070039#include <stdio.h>
40#include <stdlib.h>
San Mehatf1b736b2009-10-10 17:22:08 -070041#include <string.h>
San Mehat3578c412009-10-12 14:51:52 -070042#include <sys/stat.h>
43#include <sys/types.h>
San Mehatf1b736b2009-10-10 17:22:08 -070044
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -070045static int process_config(VolumeManager* vm, bool* has_adoptable, bool* has_quota,
46 bool* has_reserved);
Paul Crowley14c8c072018-09-18 13:30:21 -070047static void coldboot(const char* path);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070048static void parse_args(int argc, char** argv);
San Mehatf1b736b2009-10-10 17:22:08 -070049
Paul Crowley14c8c072018-09-18 13:30:21 -070050struct selabel_handle* sehandle;
Stephen Smalley684e6622014-09-30 10:29:24 -040051
Jeff Sharkey36801cc2015-03-13 16:09:20 -070052using android::base::StringPrintf;
53
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070054int main(int argc, char** argv) {
Paul Crowley0fd26262018-01-30 09:48:19 -080055 atrace_set_tracing_enabled(false);
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -070056 setenv("ANDROID_LOG_TAGS", "*:d", 1);
Jeff Sharkey5bad3782015-04-18 16:15:10 -070057 android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
San Mehatf1b736b2009-10-10 17:22:08 -070058
Paul Crowley0fd26262018-01-30 09:48:19 -080059 LOG(INFO) << "Vold 3.0 (the awakening) firing up";
60
Jeff Sharkey67b8c492017-09-21 17:08:43 -060061 ATRACE_BEGIN("main");
62
Sudheer Shanka4b6ca4e2018-09-21 10:54:54 -070063 LOG(DEBUG) << "Detected support for:"
64 << (android::vold::IsFilesystemSupported("ext4") ? " ext4" : "")
65 << (android::vold::IsFilesystemSupported("f2fs") ? " f2fs" : "")
66 << (android::vold::IsFilesystemSupported("vfat") ? " vfat" : "");
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070067
Paul Crowley14c8c072018-09-18 13:30:21 -070068 VolumeManager* vm;
69 NetlinkManager* nm;
San Mehatf1b736b2009-10-10 17:22:08 -070070
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070071 parse_args(argc, argv);
San Mehata2677e42009-12-13 10:40:18 -080072
Stephen Smalley684e6622014-09-30 10:29:24 -040073 sehandle = selinux_android_file_context_handle();
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070074 if (sehandle) {
Stephen Smalley684e6622014-09-30 10:29:24 -040075 selinux_android_set_sehandle(sehandle);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070076 }
Stephen Smalley684e6622014-09-30 10:29:24 -040077
San Mehata2677e42009-12-13 10:40:18 -080078 mkdir("/dev/block/vold", 0755);
San Mehatf1b736b2009-10-10 17:22:08 -070079
Ken Sumrallb9738ea2013-03-19 19:42:30 -070080 /* For when cryptfs checks and mounts an encrypted filesystem */
81 klog_set_level(6);
82
San Mehatf1b736b2009-10-10 17:22:08 -070083 /* Create our singleton managers */
84 if (!(vm = VolumeManager::Instance())) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070085 LOG(ERROR) << "Unable to create VolumeManager";
San Mehatf1b736b2009-10-10 17:22:08 -070086 exit(1);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070087 }
San Mehatf1b736b2009-10-10 17:22:08 -070088
89 if (!(nm = NetlinkManager::Instance())) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070090 LOG(ERROR) << "Unable to create NetlinkManager";
San Mehatf1b736b2009-10-10 17:22:08 -070091 exit(1);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070092 }
San Mehata2677e42009-12-13 10:40:18 -080093
Jeff Sharkey3472e522017-10-06 18:02:53 -060094 if (android::base::GetBoolProperty("vold.debug", false)) {
Jeff Sharkeyb0667872015-04-29 08:57:18 -070095 vm->setDebug(true);
96 }
97
San Mehatf1b736b2009-10-10 17:22:08 -070098 if (vm->start()) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070099 PLOG(ERROR) << "Unable to start VolumeManager";
San Mehatf1b736b2009-10-10 17:22:08 -0700100 exit(1);
101 }
102
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800103 bool has_adoptable;
Jeff Sharkey95a92f92017-07-17 13:57:18 -0600104 bool has_quota;
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700105 bool has_reserved;
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800106
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700107 if (process_config(vm, &has_adoptable, &has_quota, &has_reserved)) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700108 PLOG(ERROR) << "Error reading configuration... continuing anyways";
San Mehatf1b736b2009-10-10 17:22:08 -0700109 }
110
Yifan Hong024a1242018-08-10 13:50:46 -0700111 android::hardware::configureRpcThreadpool(1, false /* callerWillJoin */);
112
Paul Crowley31888052017-09-27 10:56:54 -0700113 ATRACE_BEGIN("VoldNativeService::start");
114 if (android::vold::VoldNativeService::start() != android::OK) {
115 LOG(ERROR) << "Unable to start VoldNativeService";
116 exit(1);
117 }
118 ATRACE_END();
119
Paul Crowley0fd26262018-01-30 09:48:19 -0800120 LOG(DEBUG) << "VoldNativeService::start() completed OK";
121
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600122 ATRACE_BEGIN("NetlinkManager::start");
San Mehatf1b736b2009-10-10 17:22:08 -0700123 if (nm->start()) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700124 PLOG(ERROR) << "Unable to start NetlinkManager";
San Mehatf1b736b2009-10-10 17:22:08 -0700125 exit(1);
126 }
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600127 ATRACE_END();
San Mehatf1b736b2009-10-10 17:22:08 -0700128
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800129 // This call should go after listeners are started to avoid
130 // a deadlock between vold and init (see b/34278978 for details)
Jeff Sharkey3472e522017-10-06 18:02:53 -0600131 android::base::SetProperty("vold.has_adoptable", has_adoptable ? "1" : "0");
132 android::base::SetProperty("vold.has_quota", has_quota ? "1" : "0");
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700133 android::base::SetProperty("vold.has_reserved", has_reserved ? "1" : "0");
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800134
Wei Wang2edbe282017-03-06 17:27:05 -0800135 // Do coldboot here so it won't block booting,
136 // also the cold boot is needed in case we have flash drive
137 // connected before Vold launched
138 coldboot("/sys/block");
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600139
140 ATRACE_END();
141
Jeff Sharkey93396c12017-10-18 16:52:48 -0600142 android::IPCThreadState::self()->joinThreadPool();
143 LOG(INFO) << "vold shutting down";
San Mehatf1b736b2009-10-10 17:22:08 -0700144
San Mehatf1b736b2009-10-10 17:22:08 -0700145 exit(0);
146}
147
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700148static void parse_args(int argc, char** argv) {
149 static struct option opts[] = {
Paul Crowley14c8c072018-09-18 13:30:21 -0700150 {"blkid_context", required_argument, 0, 'b'},
151 {"blkid_untrusted_context", required_argument, 0, 'B'},
152 {"fsck_context", required_argument, 0, 'f'},
153 {"fsck_untrusted_context", required_argument, 0, 'F'},
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700154 };
155
156 int c;
157 while ((c = getopt_long(argc, argv, "", opts, nullptr)) != -1) {
158 switch (c) {
Paul Crowley14c8c072018-09-18 13:30:21 -0700159 // clang-format off
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700160 case 'b': android::vold::sBlkidContext = optarg; break;
161 case 'B': android::vold::sBlkidUntrustedContext = optarg; break;
162 case 'f': android::vold::sFsckContext = optarg; break;
163 case 'F': android::vold::sFsckUntrustedContext = optarg; break;
Paul Crowley14c8c072018-09-18 13:30:21 -0700164 // clang-format on
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700165 }
166 }
167
168 CHECK(android::vold::sBlkidContext != nullptr);
169 CHECK(android::vold::sBlkidUntrustedContext != nullptr);
170 CHECK(android::vold::sFsckContext != nullptr);
171 CHECK(android::vold::sFsckUntrustedContext != nullptr);
172}
173
Paul Crowley14c8c072018-09-18 13:30:21 -0700174static void do_coldboot(DIR* d, int lvl) {
175 struct dirent* de;
Wei Wang2edbe282017-03-06 17:27:05 -0800176 int dfd, fd;
177
178 dfd = dirfd(d);
179
180 fd = openat(dfd, "uevent", O_WRONLY | O_CLOEXEC);
Paul Crowley14c8c072018-09-18 13:30:21 -0700181 if (fd >= 0) {
Wei Wang2edbe282017-03-06 17:27:05 -0800182 write(fd, "add\n", 4);
183 close(fd);
184 }
185
Paul Crowley14c8c072018-09-18 13:30:21 -0700186 while ((de = readdir(d))) {
187 DIR* d2;
Wei Wang2edbe282017-03-06 17:27:05 -0800188
Paul Crowley14c8c072018-09-18 13:30:21 -0700189 if (de->d_name[0] == '.') continue;
Wei Wang2edbe282017-03-06 17:27:05 -0800190
Paul Crowley14c8c072018-09-18 13:30:21 -0700191 if (de->d_type != DT_DIR && lvl > 0) continue;
Wei Wang2edbe282017-03-06 17:27:05 -0800192
Jeff Sharkeyfd3dc3c2017-03-27 10:49:21 -0600193 fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY | O_CLOEXEC);
Paul Crowley14c8c072018-09-18 13:30:21 -0700194 if (fd < 0) continue;
Wei Wang2edbe282017-03-06 17:27:05 -0800195
196 d2 = fdopendir(fd);
Paul Crowley14c8c072018-09-18 13:30:21 -0700197 if (d2 == 0)
Wei Wang2edbe282017-03-06 17:27:05 -0800198 close(fd);
199 else {
200 do_coldboot(d2, lvl + 1);
201 closedir(d2);
202 }
203 }
204}
205
Paul Crowley14c8c072018-09-18 13:30:21 -0700206static void coldboot(const char* path) {
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600207 ATRACE_NAME("coldboot");
Paul Crowley14c8c072018-09-18 13:30:21 -0700208 DIR* d = opendir(path);
209 if (d) {
Wei Wang2edbe282017-03-06 17:27:05 -0800210 do_coldboot(d, 0);
211 closedir(d);
212 }
213}
214
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700215static int process_config(VolumeManager* vm, bool* has_adoptable, bool* has_quota,
216 bool* has_reserved) {
Jeff Sharkey67b8c492017-09-21 17:08:43 -0600217 ATRACE_NAME("process_config");
218
Paul Crowleye2ee1522017-09-26 14:05:26 -0700219 fstab_default = fs_mgr_read_fstab_default();
220 if (!fstab_default) {
Bowgo Tsaie8fb6c32017-03-09 23:11:33 +0800221 PLOG(ERROR) << "Failed to open default fstab";
San Mehatf1b736b2009-10-10 17:22:08 -0700222 return -1;
223 }
224
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800225 /* Loop through entries looking for ones that vold manages */
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800226 *has_adoptable = false;
Jeff Sharkey95a92f92017-07-17 13:57:18 -0600227 *has_quota = false;
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700228 *has_reserved = false;
Paul Crowleye2ee1522017-09-26 14:05:26 -0700229 for (int i = 0; i < fstab_default->num_entries; i++) {
230 auto rec = &fstab_default->recs[i];
231 if (fs_mgr_is_quota(rec)) {
Jeff Sharkey95a92f92017-07-17 13:57:18 -0600232 *has_quota = true;
233 }
Jeff Sharkey53d5d7c2018-01-08 10:43:00 -0700234 if (rec->reserved_size > 0) {
235 *has_reserved = true;
236 }
Jeff Sharkey95a92f92017-07-17 13:57:18 -0600237
Paul Crowleye2ee1522017-09-26 14:05:26 -0700238 if (fs_mgr_is_voldmanaged(rec)) {
239 if (fs_mgr_is_nonremovable(rec)) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700240 LOG(WARNING) << "nonremovable no longer supported; ignoring volume";
241 continue;
San Mehata2677e42009-12-13 10:40:18 -0800242 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700243
Paul Crowleye2ee1522017-09-26 14:05:26 -0700244 std::string sysPattern(rec->blk_device);
245 std::string nickname(rec->label);
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700246 int flags = 0;
247
Paul Crowleye2ee1522017-09-26 14:05:26 -0700248 if (fs_mgr_is_encryptable(rec)) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700249 flags |= android::vold::Disk::Flags::kAdoptable;
Dimitry Ivanovc976e732017-01-19 12:48:27 -0800250 *has_adoptable = true;
San Mehatf1b736b2009-10-10 17:22:08 -0700251 }
Paul Crowley14c8c072018-09-18 13:30:21 -0700252 if (fs_mgr_is_noemulatedsd(rec) ||
253 android::base::GetBoolProperty("vold.debug.default_primary", false)) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700254 flags |= android::vold::Disk::Flags::kDefaultPrimary;
Jeff Sharkeyba6ae8d2013-07-15 18:14:25 -0700255 }
Ken Sumrall29d8da82011-05-18 17:20:07 -0700256
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700257 vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>(
Paul Crowley14c8c072018-09-18 13:30:21 -0700258 new VolumeManager::DiskSource(sysPattern, nickname, flags)));
San Mehatf1b736b2009-10-10 17:22:08 -0700259 }
260 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700261 return 0;
San Mehatf1b736b2009-10-10 17:22:08 -0700262}