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> |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 18 | #include <stdlib.h> |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 19 | #include <string.h> |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 20 | #include <errno.h> |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 21 | #include <fnmatch.h> |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 22 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 23 | #include <linux/kdev_t.h> |
| 24 | |
| 25 | #define LOG_TAG "DirectVolume" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 26 | |
| 27 | #include <cutils/log.h> |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 28 | #include <sysutils/NetlinkEvent.h> |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 29 | |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 30 | #include "DirectVolume.h" |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 31 | #include "VolumeManager.h" |
| 32 | #include "ResponseCode.h" |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 33 | #include "cryptfs.h" |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 34 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 35 | // #define PARTITION_DEBUG |
| 36 | |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 37 | PathInfo::PathInfo(const char *p) |
| 38 | { |
| 39 | warned = false; |
| 40 | pattern = strdup(p); |
| 41 | |
| 42 | if (!strchr(pattern, '*')) { |
| 43 | patternType = prefix; |
| 44 | } else { |
| 45 | patternType = wildcard; |
| 46 | } |
| 47 | } |
| 48 | |
| 49 | PathInfo::~PathInfo() |
| 50 | { |
| 51 | free(pattern); |
| 52 | } |
| 53 | |
| 54 | bool PathInfo::match(const char *path) |
| 55 | { |
| 56 | switch (patternType) { |
| 57 | case prefix: |
| 58 | { |
| 59 | bool ret = (strncmp(path, pattern, strlen(pattern)) == 0); |
| 60 | if (!warned && ret && (strlen(pattern) != strlen(path))) { |
| 61 | SLOGW("Deprecated implied prefix pattern detected, please use '%s*' instead", pattern); |
| 62 | warned = true; |
| 63 | } |
| 64 | return ret; |
| 65 | } |
| 66 | case wildcard: |
| 67 | return fnmatch(pattern, path, 0) == 0; |
| 68 | } |
| 69 | SLOGE("Bad matching type"); |
| 70 | return false; |
| 71 | } |
| 72 | |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 73 | DirectVolume::DirectVolume(VolumeManager *vm, const fstab_rec* rec, int flags) : |
| 74 | Volume(vm, rec, flags) { |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 75 | mPaths = new PathCollection(); |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 76 | for (int i = 0; i < MAX_PARTITIONS; i++) |
| 77 | mPartMinors[i] = -1; |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 78 | mPendingPartCount = 0; |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 79 | mDiskMajor = -1; |
| 80 | mDiskMinor = -1; |
| 81 | mDiskNumParts = 0; |
Cylen Yao | 33c29d6 | 2014-07-22 10:34:49 +0800 | [diff] [blame] | 82 | mIsDecrypted = 0; |
Uday Kiran Jandhyala | cef4412 | 2014-09-04 11:45:32 +0530 | [diff] [blame] | 83 | mIsValid = true; |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 84 | |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 85 | if (strcmp(rec->mount_point, "auto") != 0) { |
| 86 | ALOGE("Vold managed volumes must have auto mount point; ignoring %s", |
| 87 | rec->mount_point); |
| 88 | } |
| 89 | |
| 90 | char mount[PATH_MAX]; |
| 91 | |
| 92 | snprintf(mount, PATH_MAX, "%s/%s", Volume::MEDIA_DIR, rec->label); |
| 93 | mMountpoint = strdup(mount); |
| 94 | snprintf(mount, PATH_MAX, "%s/%s", Volume::FUSE_DIR, rec->label); |
| 95 | mFuseMountpoint = strdup(mount); |
| 96 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 97 | setState(Volume::State_NoMedia); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 98 | } |
| 99 | |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 100 | DirectVolume::~DirectVolume() { |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 101 | PathCollection::iterator it; |
| 102 | |
| 103 | for (it = mPaths->begin(); it != mPaths->end(); ++it) |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 104 | delete *it; |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 105 | delete mPaths; |
| 106 | } |
| 107 | |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 108 | int DirectVolume::addPath(const char *path) { |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 109 | mPaths->push_back(new PathInfo(path)); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 110 | return 0; |
| 111 | } |
| 112 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 113 | dev_t DirectVolume::getDiskDevice() { |
| 114 | return MKDEV(mDiskMajor, mDiskMinor); |
| 115 | } |
| 116 | |
Mike Lockwood | 2dfe297 | 2010-09-17 18:50:51 -0400 | [diff] [blame] | 117 | dev_t DirectVolume::getShareDevice() { |
| 118 | if (mPartIdx != -1) { |
| 119 | return MKDEV(mDiskMajor, mPartIdx); |
| 120 | } else { |
| 121 | return MKDEV(mDiskMajor, mDiskMinor); |
| 122 | } |
| 123 | } |
| 124 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 125 | void DirectVolume::handleVolumeShared() { |
| 126 | setState(Volume::State_Shared); |
| 127 | } |
| 128 | |
| 129 | void DirectVolume::handleVolumeUnshared() { |
| 130 | setState(Volume::State_Idle); |
| 131 | } |
| 132 | |
Uday Kiran Jandhyala | cef4412 | 2014-09-04 11:45:32 +0530 | [diff] [blame] | 133 | int DirectVolume::getUICCVolumeNum(const char *dp) { |
| 134 | int mVolNum = -1; |
| 135 | if (strstr(dp, ":0:0:0")) |
| 136 | mVolNum = 0; |
| 137 | else if (strstr(dp, ":0:0:1")) |
| 138 | mVolNum = 1; |
| 139 | |
| 140 | return mVolNum; |
| 141 | } |
| 142 | |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 143 | int DirectVolume::handleBlockEvent(NetlinkEvent *evt) { |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 144 | const char *dp = evt->findParam("DEVPATH"); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 145 | |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 146 | PathCollection::iterator it; |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 147 | for (it = mPaths->begin(); it != mPaths->end(); ++it) { |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 148 | if ((*it)->match(dp)) { |
Uday Kiran Jandhyala | cef4412 | 2014-09-04 11:45:32 +0530 | [diff] [blame] | 149 | |
| 150 | /* Check for UICC prefix in label */ |
| 151 | if (strstr(getLabel(), "uicc")) { |
| 152 | char mLabel[15]; |
| 153 | int mNum = getUICCVolumeNum(dp); |
| 154 | if (mNum < 0) { |
| 155 | SLOGE("Invalid uicc volume number"); |
| 156 | continue; |
| 157 | } |
| 158 | |
| 159 | snprintf(mLabel, sizeof(mLabel), "uicc%d", mNum); |
| 160 | if (strncmp(getLabel(), mLabel, strlen(mLabel)) != 0) |
| 161 | continue; |
| 162 | } |
| 163 | setValidSysfs(true); |
| 164 | |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 165 | /* We can handle this disk */ |
| 166 | int action = evt->getAction(); |
| 167 | const char *devtype = evt->findParam("DEVTYPE"); |
| 168 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 169 | if (action == NetlinkEvent::NlActionAdd) { |
| 170 | int major = atoi(evt->findParam("MAJOR")); |
| 171 | int minor = atoi(evt->findParam("MINOR")); |
| 172 | char nodepath[255]; |
| 173 | |
| 174 | snprintf(nodepath, |
| 175 | sizeof(nodepath), "/dev/block/vold/%d:%d", |
| 176 | major, minor); |
| 177 | if (createDeviceNode(nodepath, major, minor)) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 178 | SLOGE("Error making device node '%s' (%s)", nodepath, |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 179 | strerror(errno)); |
| 180 | } |
| 181 | if (!strcmp(devtype, "disk")) { |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 182 | handleDiskAdded(dp, evt); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 183 | } else { |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 184 | handlePartitionAdded(dp, evt); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 185 | } |
Magnus Malmborn | 3dafc26 | 2011-01-19 12:26:52 +0100 | [diff] [blame] | 186 | /* Send notification iff disk is ready (ie all partitions found) */ |
| 187 | if (getState() == Volume::State_Idle) { |
| 188 | char msg[255]; |
| 189 | |
| 190 | snprintf(msg, sizeof(msg), |
| 191 | "Volume %s %s disk inserted (%d:%d)", getLabel(), |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 192 | getFuseMountpoint(), mDiskMajor, mDiskMinor); |
Magnus Malmborn | 3dafc26 | 2011-01-19 12:26:52 +0100 | [diff] [blame] | 193 | mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted, |
| 194 | msg, false); |
| 195 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 196 | } else if (action == NetlinkEvent::NlActionRemove) { |
| 197 | if (!strcmp(devtype, "disk")) { |
| 198 | handleDiskRemoved(dp, evt); |
| 199 | } else { |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 200 | handlePartitionRemoved(dp, evt); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 201 | } |
| 202 | } else if (action == NetlinkEvent::NlActionChange) { |
| 203 | if (!strcmp(devtype, "disk")) { |
| 204 | handleDiskChanged(dp, evt); |
| 205 | } else { |
| 206 | handlePartitionChanged(dp, evt); |
| 207 | } |
| 208 | } else { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 209 | SLOGW("Ignoring non add/remove/change event"); |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 210 | } |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 211 | |
San Mehat | f1b736b | 2009-10-10 17:22:08 -0700 | [diff] [blame] | 212 | return 0; |
| 213 | } |
| 214 | } |
| 215 | errno = ENODEV; |
| 216 | return -1; |
| 217 | } |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 218 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 219 | void DirectVolume::handleDiskAdded(const char * /*devpath*/, |
| 220 | NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 221 | mDiskMajor = atoi(evt->findParam("MAJOR")); |
| 222 | mDiskMinor = atoi(evt->findParam("MINOR")); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 223 | |
| 224 | const char *tmp = evt->findParam("NPARTS"); |
| 225 | if (tmp) { |
| 226 | mDiskNumParts = atoi(tmp); |
| 227 | } else { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 228 | SLOGW("Kernel block uevent missing 'NPARTS'"); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 229 | mDiskNumParts = 1; |
| 230 | } |
| 231 | |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 232 | mPendingPartCount = mDiskNumParts; |
| 233 | for (int i = 0; i < MAX_PARTITIONS; i++) |
| 234 | mPartMinors[i] = -1; |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 235 | |
| 236 | if (mDiskNumParts == 0) { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 237 | #ifdef PARTITION_DEBUG |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 238 | SLOGD("Dv::diskIns - No partitions - good to go son!"); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 239 | #endif |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 240 | setState(Volume::State_Idle); |
| 241 | } else { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 242 | #ifdef PARTITION_DEBUG |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 243 | SLOGD("Dv::diskIns - waiting for %d pending partitions", mPendingPartCount); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 244 | #endif |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 245 | setState(Volume::State_Pending); |
| 246 | } |
| 247 | } |
| 248 | |
San Mehat | ae10b91 | 2009-10-12 14:57:05 -0700 | [diff] [blame] | 249 | void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 250 | int major = atoi(evt->findParam("MAJOR")); |
| 251 | int minor = atoi(evt->findParam("MINOR")); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 252 | |
| 253 | int part_num; |
| 254 | |
| 255 | const char *tmp = evt->findParam("PARTN"); |
| 256 | |
| 257 | if (tmp) { |
| 258 | part_num = atoi(tmp); |
| 259 | } else { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 260 | SLOGW("Kernel block uevent missing 'PARTN'"); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 261 | part_num = 1; |
| 262 | } |
San Mehat | 59abc3c | 2009-10-12 14:48:47 -0700 | [diff] [blame] | 263 | |
Nick Kralevich | f3d3ce5 | 2011-04-18 11:16:13 -0700 | [diff] [blame] | 264 | if (part_num > MAX_PARTITIONS || part_num < 1) { |
Nick Kralevich | cc8e96c | 2011-04-29 16:07:45 -0700 | [diff] [blame] | 265 | SLOGE("Invalid 'PARTN' value"); |
| 266 | return; |
Nick Kralevich | f3d3ce5 | 2011-04-18 11:16:13 -0700 | [diff] [blame] | 267 | } |
| 268 | |
San Mehat | 2a5b8ce | 2010-03-10 12:48:57 -0800 | [diff] [blame] | 269 | if (part_num > mDiskNumParts) { |
| 270 | mDiskNumParts = part_num; |
| 271 | } |
| 272 | |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 273 | if (major != mDiskMajor) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 274 | SLOGE("Partition '%s' has a different major than its disk!", devpath); |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 275 | return; |
| 276 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 277 | #ifdef PARTITION_DEBUG |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 278 | SLOGD("Dv:partAdd: part_num = %d, minor = %d\n", part_num, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 279 | #endif |
Bruce Beare | d11b833 | 2010-07-22 13:23:33 -0700 | [diff] [blame] | 280 | if (part_num >= MAX_PARTITIONS) { |
| 281 | SLOGE("Dv:partAdd: ignoring part_num = %d (max: %d)\n", part_num, MAX_PARTITIONS-1); |
Bruce Beare | d766090 | 2010-07-22 13:23:33 -0700 | [diff] [blame] | 282 | } else { |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 283 | if ((mPartMinors[part_num - 1] == -1) && mPendingPartCount) |
| 284 | mPendingPartCount--; |
Bruce Beare | d766090 | 2010-07-22 13:23:33 -0700 | [diff] [blame] | 285 | mPartMinors[part_num -1] = minor; |
| 286 | } |
Bruce Beare | d766090 | 2010-07-22 13:23:33 -0700 | [diff] [blame] | 287 | |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 288 | if (!mPendingPartCount) { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 289 | #ifdef PARTITION_DEBUG |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 290 | SLOGD("Dv:partAdd: Got all partitions - ready to rock!"); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 291 | #endif |
San Mehat | 2a5b8ce | 2010-03-10 12:48:57 -0800 | [diff] [blame] | 292 | if (getState() != Volume::State_Formatting) { |
| 293 | setState(Volume::State_Idle); |
Joseph Lehrer | 507d31b | 2011-04-11 15:02:50 -0700 | [diff] [blame] | 294 | if (mRetryMount == true) { |
| 295 | mRetryMount = false; |
| 296 | mountVol(); |
| 297 | } |
San Mehat | 2a5b8ce | 2010-03-10 12:48:57 -0800 | [diff] [blame] | 298 | } |
San Mehat | 59abc3c | 2009-10-12 14:48:47 -0700 | [diff] [blame] | 299 | } else { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 300 | #ifdef PARTITION_DEBUG |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 301 | SLOGD("Dv:partAdd: pending %d disk", mPendingPartCount); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 302 | #endif |
San Mehat | 59abc3c | 2009-10-12 14:48:47 -0700 | [diff] [blame] | 303 | } |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 304 | } |
| 305 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 306 | void DirectVolume::handleDiskChanged(const char * /*devpath*/, |
| 307 | NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 308 | int major = atoi(evt->findParam("MAJOR")); |
| 309 | int minor = atoi(evt->findParam("MINOR")); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 310 | |
| 311 | if ((major != mDiskMajor) || (minor != mDiskMinor)) { |
| 312 | return; |
| 313 | } |
| 314 | |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 315 | SLOGI("Volume %s disk has changed", getLabel()); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 316 | const char *tmp = evt->findParam("NPARTS"); |
| 317 | if (tmp) { |
| 318 | mDiskNumParts = atoi(tmp); |
| 319 | } else { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 320 | SLOGW("Kernel block uevent missing 'NPARTS'"); |
San Mehat | 7b8f2db | 2010-01-04 14:03:36 -0800 | [diff] [blame] | 321 | mDiskNumParts = 1; |
| 322 | } |
| 323 | |
Cylen Yao | b31f33b | 2014-05-12 15:56:14 +0800 | [diff] [blame] | 324 | mPendingPartCount = mDiskNumParts; |
| 325 | for (int i = 0; i < MAX_PARTITIONS; i++) |
| 326 | mPartMinors[i] = -1; |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 327 | |
San Mehat | 2a5b8ce | 2010-03-10 12:48:57 -0800 | [diff] [blame] | 328 | if (getState() != Volume::State_Formatting) { |
| 329 | if (mDiskNumParts == 0) { |
| 330 | setState(Volume::State_Idle); |
| 331 | } else { |
| 332 | setState(Volume::State_Pending); |
| 333 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 334 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 335 | } |
| 336 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 337 | void DirectVolume::handlePartitionChanged(const char * /*devpath*/, |
| 338 | NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 339 | int major = atoi(evt->findParam("MAJOR")); |
| 340 | int minor = atoi(evt->findParam("MINOR")); |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 341 | SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 342 | } |
| 343 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 344 | void DirectVolume::handleDiskRemoved(const char * /*devpath*/, |
| 345 | NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 346 | int major = atoi(evt->findParam("MAJOR")); |
| 347 | int minor = atoi(evt->findParam("MINOR")); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 348 | char msg[255]; |
Lars Svensson | 6273661 | 2011-04-07 15:17:43 +0200 | [diff] [blame] | 349 | bool enabled; |
| 350 | |
| 351 | if (mVm->shareEnabled(getLabel(), "ums", &enabled) == 0 && enabled) { |
| 352 | mVm->unshareVolume(getLabel(), "ums"); |
| 353 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 354 | |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 355 | SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 356 | snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)", |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 357 | getLabel(), getFuseMountpoint(), major, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 358 | mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved, |
| 359 | msg, false); |
padarshr | 0415e23 | 2014-08-22 15:17:41 +0530 | [diff] [blame] | 360 | |
| 361 | if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) { |
| 362 | |
| 363 | bool providesAsec = (getFlags() & VOL_PROVIDES_ASEC) != 0; |
| 364 | if (providesAsec && mVm->cleanupAsec(this, true)) { |
| 365 | SLOGE("Failed to cleanup ASEC - unmount will probably fail!"); |
| 366 | } |
| 367 | |
| 368 | if (Volume::unmountVol(true, false)) { |
| 369 | SLOGE("Failed to unmount volume on bad removal (%s)", |
| 370 | strerror(errno)); |
| 371 | // XXX: At this point we're screwed for now |
| 372 | } else { |
| 373 | SLOGD("Crisis averted"); |
| 374 | } |
| 375 | } |
| 376 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 377 | setState(Volume::State_NoMedia); |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Mark Salyzyn | 3e97127 | 2014-01-21 13:27:04 -0800 | [diff] [blame] | 380 | void DirectVolume::handlePartitionRemoved(const char * /*devpath*/, |
| 381 | NetlinkEvent *evt) { |
Kenny Root | da62e7c | 2010-03-24 20:18:00 -0700 | [diff] [blame] | 382 | int major = atoi(evt->findParam("MAJOR")); |
| 383 | int minor = atoi(evt->findParam("MINOR")); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 384 | char msg[255]; |
Ethan | 75a3e1a | 2010-07-21 23:07:51 +0800 | [diff] [blame] | 385 | int state; |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 386 | |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 387 | SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 388 | |
| 389 | /* |
| 390 | * The framework doesn't need to get notified of |
| 391 | * partition removal unless it's mounted. Otherwise |
| 392 | * the removal notification will be sent on the Disk |
| 393 | * itself |
| 394 | */ |
Ethan | 75a3e1a | 2010-07-21 23:07:51 +0800 | [diff] [blame] | 395 | state = getState(); |
| 396 | if (state != Volume::State_Mounted && state != Volume::State_Shared) { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 397 | return; |
| 398 | } |
| 399 | |
| 400 | if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) { |
| 401 | /* |
| 402 | * Yikes, our mounted partition is going away! |
| 403 | */ |
| 404 | |
Jeff Sharkey | 8c2c15b | 2013-10-17 15:17:19 -0700 | [diff] [blame] | 405 | bool providesAsec = (getFlags() & VOL_PROVIDES_ASEC) != 0; |
| 406 | if (providesAsec && mVm->cleanupAsec(this, true)) { |
| 407 | SLOGE("Failed to cleanup ASEC - unmount will probably fail!"); |
| 408 | } |
| 409 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 410 | snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)", |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 411 | getLabel(), getFuseMountpoint(), major, minor); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 412 | mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval, |
| 413 | msg, false); |
San Mehat | 1a06eda | 2010-04-15 12:58:50 -0700 | [diff] [blame] | 414 | |
Ken Sumrall | 0b8b597 | 2011-08-31 16:14:23 -0700 | [diff] [blame] | 415 | if (Volume::unmountVol(true, false)) { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 416 | SLOGE("Failed to unmount volume on bad removal (%s)", |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 417 | strerror(errno)); |
| 418 | // XXX: At this point we're screwed for now |
| 419 | } else { |
San Mehat | 97ac40e | 2010-03-24 10:24:19 -0700 | [diff] [blame] | 420 | SLOGD("Crisis averted"); |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 421 | } |
Ethan | 75a3e1a | 2010-07-21 23:07:51 +0800 | [diff] [blame] | 422 | } else if (state == Volume::State_Shared) { |
| 423 | /* removed during mass storage */ |
| 424 | snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)", |
| 425 | getLabel(), major, minor); |
| 426 | mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval, |
| 427 | msg, false); |
| 428 | |
| 429 | if (mVm->unshareVolume(getLabel(), "ums")) { |
| 430 | SLOGE("Failed to unshare volume on bad removal (%s)", |
| 431 | strerror(errno)); |
| 432 | } else { |
| 433 | SLOGD("Crisis averted"); |
| 434 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 435 | } |
San Mehat | fd7f587 | 2009-10-12 11:32:47 -0700 | [diff] [blame] | 436 | } |
San Mehat | 49e2bce | 2009-10-12 16:29:01 -0700 | [diff] [blame] | 437 | |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 438 | /* |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 439 | * Called from base to get a list of devicenodes for mounting |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 440 | */ |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 441 | int DirectVolume::getDeviceNodes(dev_t *devs, int max) { |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 442 | |
| 443 | if (mPartIdx == -1) { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 444 | // If the disk has no partitions, try the disk itself |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 445 | if (!mDiskNumParts) { |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 446 | devs[0] = MKDEV(mDiskMajor, mDiskMinor); |
| 447 | return 1; |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 448 | } |
| 449 | |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 450 | int i; |
| 451 | for (i = 0; i < mDiskNumParts; i++) { |
| 452 | if (i == max) |
| 453 | break; |
| 454 | devs[i] = MKDEV(mDiskMajor, mPartMinors[i]); |
| 455 | } |
| 456 | return mDiskNumParts; |
San Mehat | dd9b8e9 | 2009-10-21 11:06:52 -0700 | [diff] [blame] | 457 | } |
San Mehat | a2677e4 | 2009-12-13 10:40:18 -0800 | [diff] [blame] | 458 | devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]); |
| 459 | return 1; |
San Mehat | 49e2bce | 2009-10-12 16:29:01 -0700 | [diff] [blame] | 460 | } |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 461 | |
| 462 | /* |
| 463 | * Called from base to update device info, |
| 464 | * e.g. When setting up an dm-crypt mapping for the sd card. |
| 465 | */ |
| 466 | int DirectVolume::updateDeviceInfo(char *new_path, int new_major, int new_minor) |
| 467 | { |
| 468 | PathCollection::iterator it; |
| 469 | |
| 470 | if (mPartIdx == -1) { |
| 471 | SLOGE("Can only change device info on a partition\n"); |
| 472 | return -1; |
| 473 | } |
| 474 | |
| 475 | /* |
| 476 | * This is to change the sysfs path associated with a partition, in particular, |
| 477 | * for an internal SD card partition that is encrypted. Thus, the list is |
| 478 | * expected to be only 1 entry long. Check that and bail if not. |
| 479 | */ |
| 480 | if (mPaths->size() != 1) { |
| 481 | SLOGE("Cannot change path if there are more than one for a volume\n"); |
| 482 | return -1; |
| 483 | } |
| 484 | |
| 485 | it = mPaths->begin(); |
Octavian Purdila | 46c301c | 2014-05-05 15:13:12 +0300 | [diff] [blame] | 486 | delete *it; /* Free the string storage */ |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 487 | mPaths->erase(it); /* Remove it from the list */ |
| 488 | addPath(new_path); /* Put the new path on the list */ |
| 489 | |
Ken Sumrall | 0b8b597 | 2011-08-31 16:14:23 -0700 | [diff] [blame] | 490 | /* Save away original info so we can restore it when doing factory reset. |
| 491 | * Then, when doing the format, it will format the original device in the |
| 492 | * clear, otherwise it just formats the encrypted device which is not |
| 493 | * readable when the device boots unencrypted after the reset. |
| 494 | */ |
| 495 | mOrigDiskMajor = mDiskMajor; |
| 496 | mOrigDiskMinor = mDiskMinor; |
| 497 | mOrigPartIdx = mPartIdx; |
| 498 | memcpy(mOrigPartMinors, mPartMinors, sizeof(mPartMinors)); |
| 499 | |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 500 | mDiskMajor = new_major; |
| 501 | mDiskMinor = new_minor; |
| 502 | /* Ugh, virual block devices don't use minor 0 for whole disk and minor > 0 for |
| 503 | * partition number. They don't have partitions, they are just virtual block |
| 504 | * devices, and minor number 0 is the first dm-crypt device. Luckily the first |
| 505 | * dm-crypt device is for the userdata partition, which gets minor number 0, and |
| 506 | * it is not managed by vold. So the next device is minor number one, which we |
| 507 | * will call partition one. |
| 508 | */ |
| 509 | mPartIdx = new_minor; |
| 510 | mPartMinors[new_minor-1] = new_minor; |
| 511 | |
| 512 | mIsDecrypted = 1; |
| 513 | |
| 514 | return 0; |
| 515 | } |
| 516 | |
| 517 | /* |
Ken Sumrall | 0b8b597 | 2011-08-31 16:14:23 -0700 | [diff] [blame] | 518 | * Called from base to revert device info to the way it was before a |
| 519 | * crypto mapping was created for it. |
| 520 | */ |
| 521 | void DirectVolume::revertDeviceInfo(void) |
| 522 | { |
| 523 | if (mIsDecrypted) { |
| 524 | mDiskMajor = mOrigDiskMajor; |
| 525 | mDiskMinor = mOrigDiskMinor; |
| 526 | mPartIdx = mOrigPartIdx; |
| 527 | memcpy(mPartMinors, mOrigPartMinors, sizeof(mPartMinors)); |
| 528 | |
| 529 | mIsDecrypted = 0; |
| 530 | } |
| 531 | |
| 532 | return; |
| 533 | } |
| 534 | |
| 535 | /* |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 536 | * Called from base to give cryptfs all the info it needs to encrypt eligible volumes |
| 537 | */ |
| 538 | int DirectVolume::getVolInfo(struct volume_info *v) |
| 539 | { |
| 540 | strcpy(v->label, mLabel); |
| 541 | strcpy(v->mnt_point, mMountpoint); |
Jeff Sharkey | ba6ae8d | 2013-07-15 18:14:25 -0700 | [diff] [blame] | 542 | v->flags = getFlags(); |
Ken Sumrall | 29d8da8 | 2011-05-18 17:20:07 -0700 | [diff] [blame] | 543 | /* Other fields of struct volume_info are filled in by the caller or cryptfs.c */ |
| 544 | |
| 545 | return 0; |
| 546 | } |