San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 1 | /* |
| 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 | |
| 17 | #include <stdio.h> |
| 18 | #include <stdlib.h> |
| 19 | #include <errno.h> |
| 20 | #include <string.h> |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 21 | #include <sys/stat.h> |
| 22 | #include <sys/types.h> |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 23 | #include <getopt.h> |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 24 | |
| 25 | #include <fcntl.h> |
| 26 | #include <dirent.h> |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 27 | #include <fs_mgr.h> |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 28 | |
| 29 | #define LOG_TAG "Vold" |
| 30 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 31 | #include <base/logging.h> |
| 32 | #include <base/stringprintf.h> |
Ken Sumrall | b9738ea | 2013-03-19 19:42:30 -0700 | [diff] [blame] | 33 | #include "cutils/klog.h" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 34 | #include "cutils/log.h" |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 35 | #include "cutils/properties.h" |
Jeff Sharkey | f7e86ea | 2015-04-01 23:07:19 -0700 | [diff] [blame^] | 36 | #include "cutils/sockets.h" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 37 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 38 | #include "Disk.h" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 39 | #include "VolumeManager.h" |
| 40 | #include "CommandListener.h" |
| 41 | #include "NetlinkManager.h" |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 42 | #include "DirectVolume.h" |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 43 | #include "cryptfs.h" |
Stephen Smalley | 684e662 | 2014-09-30 10:29:24 -0400 | [diff] [blame] | 44 | #include "sehandle.h" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 45 | |
| 46 | static int process_config(VolumeManager *vm); |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 47 | static void coldboot(const char *path); |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 48 | static void parse_args(int argc, char** argv); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 49 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 50 | //#define DEBUG_FSTAB "/data/local/tmp/fstab.debug" |
| 51 | |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 52 | struct fstab *fstab; |
| 53 | |
Stephen Smalley | 684e662 | 2014-09-30 10:29:24 -0400 | [diff] [blame] | 54 | struct selabel_handle *sehandle; |
| 55 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 56 | using android::base::StringPrintf; |
| 57 | |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 58 | int main(int argc, char** argv) { |
| 59 | SLOGI("Vold 2.1 (the revenge) firing up"); |
| 60 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 61 | setenv("ANDROID_LOG_TAGS", "*:v", 1); |
| 62 | android::base::InitLogging(argv); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 63 | |
| 64 | VolumeManager *vm; |
| 65 | CommandListener *cl; |
| 66 | NetlinkManager *nm; |
| 67 | |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 68 | parse_args(argc, argv); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 69 | |
Stephen Smalley | 684e662 | 2014-09-30 10:29:24 -0400 | [diff] [blame] | 70 | sehandle = selinux_android_file_context_handle(); |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 71 | if (sehandle) { |
Stephen Smalley | 684e662 | 2014-09-30 10:29:24 -0400 | [diff] [blame] | 72 | selinux_android_set_sehandle(sehandle); |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 73 | } |
Stephen Smalley | 684e662 | 2014-09-30 10:29:24 -0400 | [diff] [blame] | 74 | |
Jeff Sharkey | f7e86ea | 2015-04-01 23:07:19 -0700 | [diff] [blame^] | 75 | // Quickly throw a CLOEXEC on the socket we just inherited from init |
| 76 | fcntl(android_get_control_socket("vold"), F_SETFD, FD_CLOEXEC); |
| 77 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 78 | mkdir("/dev/block/vold", 0755); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 79 | |
Ken Sumrall | b9738ea | 2013-03-19 19:42:30 -0700 | [diff] [blame] | 80 | /* For when cryptfs checks and mounts an encrypted filesystem */ |
| 81 | klog_set_level(6); |
| 82 | |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 83 | /* Create our singleton managers */ |
| 84 | if (!(vm = VolumeManager::Instance())) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 85 | SLOGE("Unable to create VolumeManager"); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 86 | exit(1); |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 87 | } |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 88 | |
| 89 | if (!(nm = NetlinkManager::Instance())) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 90 | SLOGE("Unable to create NetlinkManager"); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 91 | exit(1); |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 92 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 93 | |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 94 | cl = new CommandListener(); |
| 95 | vm->setBroadcaster((SocketListener *) cl); |
| 96 | nm->setBroadcaster((SocketListener *) cl); |
| 97 | |
| 98 | if (vm->start()) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 99 | SLOGE("Unable to start VolumeManager (%s)", strerror(errno)); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 100 | exit(1); |
| 101 | } |
| 102 | |
| 103 | if (process_config(vm)) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 104 | SLOGE("Error reading configuration (%s)... continuing anyways", strerror(errno)); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | if (nm->start()) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 108 | SLOGE("Unable to start NetlinkManager (%s)", strerror(errno)); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 109 | exit(1); |
| 110 | } |
| 111 | |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 112 | coldboot("/sys/block"); |
San Mehat | 0cde53c | 2009-12-22 08:32:33 -0800 | [diff] [blame] | 113 | // coldboot("/sys/class/switch"); |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 114 | |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 115 | /* |
| 116 | * Now that we're up, we can respond to commands |
| 117 | */ |
| 118 | if (cl->startListener()) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 119 | SLOGE("Unable to start CommandListener (%s)", strerror(errno)); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 120 | exit(1); |
| 121 | } |
| 122 | |
| 123 | // Eventually we'll become the monitoring thread |
| 124 | while(1) { |
| 125 | sleep(1000); |
| 126 | } |
| 127 | |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 128 | SLOGI("Vold exiting"); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 129 | exit(0); |
| 130 | } |
| 131 | |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 132 | static void parse_args(int argc, char** argv) { |
| 133 | static struct option opts[] = { |
| 134 | {"blkid_context", required_argument, 0, 'b' }, |
| 135 | {"blkid_untrusted_context", required_argument, 0, 'B' }, |
| 136 | {"fsck_context", required_argument, 0, 'f' }, |
| 137 | {"fsck_untrusted_context", required_argument, 0, 'F' }, |
| 138 | }; |
| 139 | |
| 140 | int c; |
| 141 | while ((c = getopt_long(argc, argv, "", opts, nullptr)) != -1) { |
| 142 | switch (c) { |
| 143 | case 'b': android::vold::sBlkidContext = optarg; break; |
| 144 | case 'B': android::vold::sBlkidUntrustedContext = optarg; break; |
| 145 | case 'f': android::vold::sFsckContext = optarg; break; |
| 146 | case 'F': android::vold::sFsckUntrustedContext = optarg; break; |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | CHECK(android::vold::sBlkidContext != nullptr); |
| 151 | CHECK(android::vold::sBlkidUntrustedContext != nullptr); |
| 152 | CHECK(android::vold::sFsckContext != nullptr); |
| 153 | CHECK(android::vold::sFsckUntrustedContext != nullptr); |
| 154 | } |
| 155 | |
| 156 | static void do_coldboot(DIR *d, int lvl) { |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 157 | struct dirent *de; |
| 158 | int dfd, fd; |
| 159 | |
| 160 | dfd = dirfd(d); |
| 161 | |
Jeff Sharkey | f7e86ea | 2015-04-01 23:07:19 -0700 | [diff] [blame^] | 162 | fd = openat(dfd, "uevent", O_WRONLY | O_CLOEXEC); |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 163 | if(fd >= 0) { |
| 164 | write(fd, "add\n", 4); |
| 165 | close(fd); |
| 166 | } |
| 167 | |
| 168 | while((de = readdir(d))) { |
| 169 | DIR *d2; |
| 170 | |
| 171 | if (de->d_name[0] == '.') |
| 172 | continue; |
| 173 | |
| 174 | if (de->d_type != DT_DIR && lvl > 0) |
| 175 | continue; |
| 176 | |
| 177 | fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY); |
| 178 | if(fd < 0) |
| 179 | continue; |
| 180 | |
| 181 | d2 = fdopendir(fd); |
| 182 | if(d2 == 0) |
| 183 | close(fd); |
| 184 | else { |
| 185 | do_coldboot(d2, lvl + 1); |
| 186 | closedir(d2); |
| 187 | } |
| 188 | } |
| 189 | } |
| 190 | |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 191 | static void coldboot(const char *path) { |
San Mehat | 3578c41 | 2009-10-12 14:51:52 -0700 | [diff] [blame] | 192 | DIR *d = opendir(path); |
| 193 | if(d) { |
| 194 | do_coldboot(d, 0); |
| 195 | closedir(d); |
| 196 | } |
| 197 | } |
| 198 | |
Jeff Sharkey | 95c87cc | 2015-04-01 11:54:32 -0700 | [diff] [blame] | 199 | static int process_config(VolumeManager *vm) { |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 200 | char hardware[PROPERTY_VALUE_MAX]; |
| 201 | property_get("ro.hardware", hardware, ""); |
| 202 | std::string fstab_filename(StringPrintf("/fstab.%s", hardware)); |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 203 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 204 | #ifdef DEBUG_FSTAB |
| 205 | if (access(DEBUG_FSTAB, R_OK) == 0) { |
| 206 | LOG(DEBUG) << "Found debug fstab; switching!"; |
| 207 | fstab_filename = DEBUG_FSTAB; |
| 208 | } |
| 209 | #endif |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 210 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 211 | fstab = fs_mgr_read_fstab(fstab_filename.c_str()); |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 212 | if (!fstab) { |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 213 | PLOG(ERROR) << "Failed to open " << fstab_filename; |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 214 | return -1; |
| 215 | } |
| 216 | |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 217 | /* Loop through entries looking for ones that vold manages */ |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 218 | for (int i = 0; i < fstab->num_entries; i++) { |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 219 | if (fs_mgr_is_voldmanaged(&fstab->recs[i])) { |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 220 | if (fs_mgr_is_nonremovable(&fstab->recs[i])) { |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 221 | LOG(WARNING) << "nonremovable no longer supported; ignoring volume"; |
| 222 | continue; |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 223 | } |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 224 | |
| 225 | std::string sysPattern(fstab->recs[i].blk_device); |
| 226 | std::string nickname(fstab->recs[i].label); |
| 227 | int flags = 0; |
| 228 | |
Ken Sumrall | 56ad03c | 2013-02-13 13:00:19 -0800 | [diff] [blame] | 229 | if (fs_mgr_is_encryptable(&fstab->recs[i])) { |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 230 | flags |= android::vold::Disk::Flags::kAdoptable; |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 231 | } |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 232 | if (fs_mgr_is_noemulatedsd(&fstab->recs[i])) { |
| 233 | flags |= android::vold::Disk::Flags::kDefaultPrimary; |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 234 | } |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 235 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 236 | vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>( |
| 237 | new VolumeManager::DiskSource(sysPattern, nickname, flags))); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 238 | } |
| 239 | } |
| 240 | |
Jeff Sharkey | 36801cc | 2015-03-13 16:09:20 -0700 | [diff] [blame] | 241 | return 0; |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 242 | } |