blob: 9cbcf888787d9f49110d388b9d5096fab012640f [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 Sharkey9f18fe72015-04-01 23:32:18 -070017#include "Disk.h"
18#include "VolumeManager.h"
19#include "CommandListener.h"
Paul Lawrenced0b42952015-06-03 14:19:51 -070020#include "CryptCommandListener.h"
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070021#include "NetlinkManager.h"
22#include "cryptfs.h"
23#include "sehandle.h"
24
Elliott Hughes7e128fb2015-12-04 15:50:53 -080025#include <android-base/logging.h>
26#include <android-base/stringprintf.h>
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070027#include <cutils/klog.h>
28#include <cutils/properties.h>
29#include <cutils/sockets.h>
30
San Mehatf1b736b2009-10-10 17:22:08 -070031#include <stdio.h>
32#include <stdlib.h>
33#include <errno.h>
34#include <string.h>
San Mehat3578c412009-10-12 14:51:52 -070035#include <sys/stat.h>
36#include <sys/types.h>
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070037#include <getopt.h>
San Mehat3578c412009-10-12 14:51:52 -070038#include <fcntl.h>
39#include <dirent.h>
Ken Sumrall56ad03c2013-02-13 13:00:19 -080040#include <fs_mgr.h>
San Mehatf1b736b2009-10-10 17:22:08 -070041
San Mehatf1b736b2009-10-10 17:22:08 -070042static int process_config(VolumeManager *vm);
San Mehat3578c412009-10-12 14:51:52 -070043static void coldboot(const char *path);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070044static void parse_args(int argc, char** argv);
San Mehatf1b736b2009-10-10 17:22:08 -070045
Ken Sumrall56ad03c2013-02-13 13:00:19 -080046struct fstab *fstab;
47
Stephen Smalley684e6622014-09-30 10:29:24 -040048struct selabel_handle *sehandle;
49
Jeff Sharkey36801cc2015-03-13 16:09:20 -070050using android::base::StringPrintf;
51
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070052int main(int argc, char** argv) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -070053 setenv("ANDROID_LOG_TAGS", "*:v", 1);
Jeff Sharkey5bad3782015-04-18 16:15:10 -070054 android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
San Mehatf1b736b2009-10-10 17:22:08 -070055
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070056 LOG(INFO) << "Vold 3.0 (the awakening) firing up";
57
Jeff Sharkeyd0640f62015-05-21 22:35:42 -070058 LOG(VERBOSE) << "Detected support for:"
59 << (android::vold::IsFilesystemSupported("ext4") ? " ext4" : "")
60 << (android::vold::IsFilesystemSupported("f2fs") ? " f2fs" : "")
61 << (android::vold::IsFilesystemSupported("vfat") ? " vfat" : "");
62
San Mehatf1b736b2009-10-10 17:22:08 -070063 VolumeManager *vm;
64 CommandListener *cl;
Paul Lawrenced0b42952015-06-03 14:19:51 -070065 CryptCommandListener *ccl;
San Mehatf1b736b2009-10-10 17:22:08 -070066 NetlinkManager *nm;
67
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070068 parse_args(argc, argv);
San Mehata2677e42009-12-13 10:40:18 -080069
Stephen Smalley684e6622014-09-30 10:29:24 -040070 sehandle = selinux_android_file_context_handle();
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070071 if (sehandle) {
Stephen Smalley684e6622014-09-30 10:29:24 -040072 selinux_android_set_sehandle(sehandle);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070073 }
Stephen Smalley684e6622014-09-30 10:29:24 -040074
Jeff Sharkeyf7e86ea2015-04-01 23:07:19 -070075 // Quickly throw a CLOEXEC on the socket we just inherited from init
76 fcntl(android_get_control_socket("vold"), F_SETFD, FD_CLOEXEC);
Paul Lawrenced0b42952015-06-03 14:19:51 -070077 fcntl(android_get_control_socket("cryptd"), F_SETFD, FD_CLOEXEC);
Jeff Sharkeyf7e86ea2015-04-01 23:07:19 -070078
San Mehata2677e42009-12-13 10:40:18 -080079 mkdir("/dev/block/vold", 0755);
San Mehatf1b736b2009-10-10 17:22:08 -070080
Ken Sumrallb9738ea2013-03-19 19:42:30 -070081 /* For when cryptfs checks and mounts an encrypted filesystem */
82 klog_set_level(6);
83
San Mehatf1b736b2009-10-10 17:22:08 -070084 /* Create our singleton managers */
85 if (!(vm = VolumeManager::Instance())) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070086 LOG(ERROR) << "Unable to create VolumeManager";
San Mehatf1b736b2009-10-10 17:22:08 -070087 exit(1);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070088 }
San Mehatf1b736b2009-10-10 17:22:08 -070089
90 if (!(nm = NetlinkManager::Instance())) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -070091 LOG(ERROR) << "Unable to create NetlinkManager";
San Mehatf1b736b2009-10-10 17:22:08 -070092 exit(1);
Jeff Sharkey95c87cc2015-04-01 11:54:32 -070093 }
San Mehata2677e42009-12-13 10:40:18 -080094
Jeff Sharkeyb0667872015-04-29 08:57:18 -070095 if (property_get_bool("vold.debug", false)) {
96 vm->setDebug(true);
97 }
98
San Mehatf1b736b2009-10-10 17:22:08 -070099 cl = new CommandListener();
Paul Lawrenced0b42952015-06-03 14:19:51 -0700100 ccl = new CryptCommandListener();
San Mehatf1b736b2009-10-10 17:22:08 -0700101 vm->setBroadcaster((SocketListener *) cl);
102 nm->setBroadcaster((SocketListener *) cl);
103
104 if (vm->start()) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700105 PLOG(ERROR) << "Unable to start VolumeManager";
San Mehatf1b736b2009-10-10 17:22:08 -0700106 exit(1);
107 }
108
109 if (process_config(vm)) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700110 PLOG(ERROR) << "Error reading configuration... continuing anyways";
San Mehatf1b736b2009-10-10 17:22:08 -0700111 }
112
113 if (nm->start()) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700114 PLOG(ERROR) << "Unable to start NetlinkManager";
San Mehatf1b736b2009-10-10 17:22:08 -0700115 exit(1);
116 }
117
San Mehat3578c412009-10-12 14:51:52 -0700118 coldboot("/sys/block");
San Mehat0cde53c2009-12-22 08:32:33 -0800119// coldboot("/sys/class/switch");
San Mehat3578c412009-10-12 14:51:52 -0700120
San Mehatf1b736b2009-10-10 17:22:08 -0700121 /*
122 * Now that we're up, we can respond to commands
123 */
124 if (cl->startListener()) {
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700125 PLOG(ERROR) << "Unable to start CommandListener";
San Mehatf1b736b2009-10-10 17:22:08 -0700126 exit(1);
127 }
128
Paul Lawrenced0b42952015-06-03 14:19:51 -0700129 if (ccl->startListener()) {
130 PLOG(ERROR) << "Unable to start CryptCommandListener";
131 exit(1);
132 }
133
San Mehatf1b736b2009-10-10 17:22:08 -0700134 // Eventually we'll become the monitoring thread
135 while(1) {
136 sleep(1000);
137 }
138
Jeff Sharkey9f18fe72015-04-01 23:32:18 -0700139 LOG(ERROR) << "Vold exiting";
San Mehatf1b736b2009-10-10 17:22:08 -0700140 exit(0);
141}
142
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700143static void parse_args(int argc, char** argv) {
144 static struct option opts[] = {
145 {"blkid_context", required_argument, 0, 'b' },
146 {"blkid_untrusted_context", required_argument, 0, 'B' },
147 {"fsck_context", required_argument, 0, 'f' },
148 {"fsck_untrusted_context", required_argument, 0, 'F' },
149 };
150
151 int c;
152 while ((c = getopt_long(argc, argv, "", opts, nullptr)) != -1) {
153 switch (c) {
154 case 'b': android::vold::sBlkidContext = optarg; break;
155 case 'B': android::vold::sBlkidUntrustedContext = optarg; break;
156 case 'f': android::vold::sFsckContext = optarg; break;
157 case 'F': android::vold::sFsckUntrustedContext = optarg; break;
158 }
159 }
160
161 CHECK(android::vold::sBlkidContext != nullptr);
162 CHECK(android::vold::sBlkidUntrustedContext != nullptr);
163 CHECK(android::vold::sFsckContext != nullptr);
164 CHECK(android::vold::sFsckUntrustedContext != nullptr);
165}
166
167static void do_coldboot(DIR *d, int lvl) {
San Mehat3578c412009-10-12 14:51:52 -0700168 struct dirent *de;
169 int dfd, fd;
170
171 dfd = dirfd(d);
172
Jeff Sharkeyf7e86ea2015-04-01 23:07:19 -0700173 fd = openat(dfd, "uevent", O_WRONLY | O_CLOEXEC);
San Mehat3578c412009-10-12 14:51:52 -0700174 if(fd >= 0) {
175 write(fd, "add\n", 4);
176 close(fd);
177 }
178
179 while((de = readdir(d))) {
180 DIR *d2;
181
182 if (de->d_name[0] == '.')
183 continue;
184
185 if (de->d_type != DT_DIR && lvl > 0)
186 continue;
187
188 fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);
189 if(fd < 0)
190 continue;
191
192 d2 = fdopendir(fd);
193 if(d2 == 0)
194 close(fd);
195 else {
196 do_coldboot(d2, lvl + 1);
197 closedir(d2);
198 }
199 }
200}
201
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700202static void coldboot(const char *path) {
San Mehat3578c412009-10-12 14:51:52 -0700203 DIR *d = opendir(path);
204 if(d) {
205 do_coldboot(d, 0);
206 closedir(d);
207 }
208}
209
Jeff Sharkey95c87cc2015-04-01 11:54:32 -0700210static int process_config(VolumeManager *vm) {
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700211 std::string path(android::vold::DefaultFstabPath());
212 fstab = fs_mgr_read_fstab(path.c_str());
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800213 if (!fstab) {
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700214 PLOG(ERROR) << "Failed to open default fstab " << path;
San Mehatf1b736b2009-10-10 17:22:08 -0700215 return -1;
216 }
217
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800218 /* Loop through entries looking for ones that vold manages */
Jeff Sharkeyc86ab6f2015-06-26 14:02:09 -0700219 bool has_adoptable = false;
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700220 for (int i = 0; i < fstab->num_entries; i++) {
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800221 if (fs_mgr_is_voldmanaged(&fstab->recs[i])) {
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800222 if (fs_mgr_is_nonremovable(&fstab->recs[i])) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700223 LOG(WARNING) << "nonremovable no longer supported; ignoring volume";
224 continue;
San Mehata2677e42009-12-13 10:40:18 -0800225 }
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700226
227 std::string sysPattern(fstab->recs[i].blk_device);
228 std::string nickname(fstab->recs[i].label);
229 int flags = 0;
230
Ken Sumrall56ad03c2013-02-13 13:00:19 -0800231 if (fs_mgr_is_encryptable(&fstab->recs[i])) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700232 flags |= android::vold::Disk::Flags::kAdoptable;
Jeff Sharkeye44a41a2015-05-13 13:53:07 -0700233 has_adoptable = true;
San Mehatf1b736b2009-10-10 17:22:08 -0700234 }
Jeff Sharkey65427f12015-05-19 15:54:15 -0700235 if (fs_mgr_is_noemulatedsd(&fstab->recs[i])
236 || property_get_bool("vold.debug.default_primary", false)) {
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700237 flags |= android::vold::Disk::Flags::kDefaultPrimary;
Jeff Sharkeyba6ae8d2013-07-15 18:14:25 -0700238 }
Ken Sumrall29d8da82011-05-18 17:20:07 -0700239
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700240 vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>(
241 new VolumeManager::DiskSource(sysPattern, nickname, flags)));
San Mehatf1b736b2009-10-10 17:22:08 -0700242 }
243 }
Jeff Sharkeye44a41a2015-05-13 13:53:07 -0700244 property_set("vold.has_adoptable", has_adoptable ? "1" : "0");
Jeff Sharkey36801cc2015-03-13 16:09:20 -0700245 return 0;
San Mehatf1b736b2009-10-10 17:22:08 -0700246}