Volume.cpp revision 64382de1f93b84ca59f607da4b4fdbd77f1af67d
19066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 29066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Copyright (C) 2008 The Android Open Source Project 39066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 49066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 59066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * you may not use this file except in compliance with the License. 69066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * You may obtain a copy of the License at 79066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 89066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 99066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * 109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * See the License for the specific language governing permissions and 149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * limitations under the License. 159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <stdlib.h> 189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <string.h> 199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <dirent.h> 209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <errno.h> 219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <fcntl.h> 229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <sys/types.h> 249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <sys/stat.h> 259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <sys/types.h> 269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <sys/mman.h> 279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <sys/mount.h> 289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <linux/kdev_t.h> 309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <cutils/properties.h> 329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <diskconfig/diskconfig.h> 349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#define LOG_TAG "Vold" 369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 379066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include <cutils/log.h> 389066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 399066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "Volume.h" 409066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "VolumeManager.h" 419066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "ResponseCode.h" 429066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "Fat.h" 439066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project#include "Process.h" 449066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 459066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectextern "C" void dos_partition_dec(void const *pp, struct dos_partition *d); 469066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectextern "C" void dos_partition_enc(void *pp, struct dos_partition *d); 479066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 489066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 499066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 509066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Secure directory - stuff that only root can see 519066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 529066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectconst char *Volume::SECDIR = "/mnt/secure"; 539066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 549066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 559066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Secure staging directory - where media is mounted for preparation 569066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 579066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectconst char *Volume::SEC_STGDIR = "/mnt/secure/staging"; 589066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 599066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 609066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Path to the directory on the media which contains publicly accessable 619066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * asec imagefiles. This path will be obscured before the mount is 629066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * exposed to non priviledged users. 639066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 649066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectconst char *Volume::SEC_STG_SECIMGDIR = "/mnt/secure/staging/.android_secure"; 659066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 669066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 679066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Path to where *only* root can access asec imagefiles 689066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 699066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectconst char *Volume::SEC_ASECDIR = "/mnt/secure/asec"; 709066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 719066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project/* 729066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Path to where secure containers are mounted 739066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 749066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectconst char *Volume::ASECDIR = "/mnt/asec"; 759066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 769066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectstatic const char *stateToStr(int state) { 779066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (state == Volume::State_Init) 789066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Initializing"; 799066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_NoMedia) 809066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "No-Media"; 819066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Idle) 829066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Idle-Unmounted"; 839066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Pending) 849066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Pending"; 859066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Mounted) 869066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Mounted"; 879066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Unmounting) 889066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Unmounting"; 899066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Checking) 909066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Checking"; 919066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Formatting) 929066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Formatting"; 939066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else if (state == Volume::State_Shared) 949066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Shared-Unmounted"; 95196863d27407e23c69debdd061df58ce8fe76c20Gloria Wang else if (state == Volume::State_SharedMnt) 969066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Shared-Mounted"; 979066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project else 989066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project return "Unknown-Error"; 999066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 1009066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1019066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source ProjectVolume::Volume(VolumeManager *vm, const char *label, const char *mount_point) { 1029066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mVm = vm; 1039066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mDebug = false; 1049066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mLabel = strdup(label); 1059066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mMountpoint = strdup(mount_point); 1069066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mState = Volume::State_Init; 1079066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mCurrentlyMountedKdev = -1; 1089066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 1099066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1109066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source ProjectVolume::~Volume() { 1119066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project free(mLabel); 1129066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project free(mMountpoint); 1139066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 1149066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1159066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectvoid Volume::protectFromAutorunStupidity() { 1169066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project char filename[255]; 1179066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1189066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project snprintf(filename, sizeof(filename), "%s/autorun.inf", SEC_STGDIR); 1199066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (!access(filename, F_OK)) { 1209066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SLOGW("Volume contains an autorun.inf! - removing"); 1219066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project /* 1229066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Ensure the filename is all lower-case so 1239066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * the process killer can find the inode. 1249066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project * Probably being paranoid here but meh. 1259066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project */ 1269066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project rename(filename, filename); 1279066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project Process::killProcessesWithOpenFiles(filename, 2); 1289066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project if (unlink(filename)) { 1299066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project SLOGE("Failed to remove %s (%s)", filename, strerror(errno)); 1309066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1319066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project } 1329066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 1339066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project 1349066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Projectvoid Volume::setDebug(bool enable) { 1359066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project mDebug = enable; 1369066cfe9886ac131c34d59ed0e2d287b0e3c0087The Android Open Source Project} 137 138dev_t Volume::getDiskDevice() { 139 return MKDEV(0, 0); 140}; 141 142void Volume::handleVolumeShared() { 143} 144 145void Volume::handleVolumeUnshared() { 146} 147 148int Volume::handleBlockEvent(NetlinkEvent *evt) { 149 errno = ENOSYS; 150 return -1; 151} 152 153void Volume::setState(int state) { 154 char msg[255]; 155 int oldState = mState; 156 157 if (oldState == state) { 158 SLOGW("Duplicate state (%d)\n", state); 159 return; 160 } 161 162 mState = state; 163 164 SLOGD("Volume %s state changing %d (%s) -> %d (%s)", mLabel, 165 oldState, stateToStr(oldState), mState, stateToStr(mState)); 166 snprintf(msg, sizeof(msg), 167 "Volume %s %s state changed from %d (%s) to %d (%s)", getLabel(), 168 getMountpoint(), oldState, stateToStr(oldState), mState, 169 stateToStr(mState)); 170 171 mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeStateChange, 172 msg, false); 173} 174 175int Volume::createDeviceNode(const char *path, int major, int minor) { 176 mode_t mode = 0660 | S_IFBLK; 177 dev_t dev = (major << 8) | minor; 178 if (mknod(path, mode, dev) < 0) { 179 if (errno != EEXIST) { 180 return -1; 181 } 182 } 183 return 0; 184} 185 186int Volume::formatVol() { 187 188 if (getState() == Volume::State_NoMedia) { 189 errno = ENODEV; 190 return -1; 191 } else if (getState() != Volume::State_Idle) { 192 errno = EBUSY; 193 return -1; 194 } 195 196 if (isMountpointMounted(getMountpoint())) { 197 SLOGW("Volume is idle but appears to be mounted - fixing"); 198 setState(Volume::State_Mounted); 199 // mCurrentlyMountedKdev = XXX 200 errno = EBUSY; 201 return -1; 202 } 203 204 char devicePath[255]; 205 dev_t diskNode = getDiskDevice(); 206 dev_t partNode = MKDEV(MAJOR(diskNode), 1); // XXX: Hmmm 207 208 sprintf(devicePath, "/dev/block/vold/%d:%d", 209 MAJOR(diskNode), MINOR(diskNode)); 210 211 if (mDebug) { 212 SLOGI("Formatting volume %s (%s)", getLabel(), devicePath); 213 } 214 setState(Volume::State_Formatting); 215 216 int ret = -1; 217 if (initializeMbr(devicePath)) { 218 SLOGE("Failed to initialize MBR (%s)", strerror(errno)); 219 goto err; 220 } 221 222 sprintf(devicePath, "/dev/block/vold/%d:%d", 223 MAJOR(partNode), MINOR(partNode)); 224 225 if (Fat::format(devicePath, 0)) { 226 SLOGE("Failed to format (%s)", strerror(errno)); 227 goto err; 228 } 229 230 ret = 0; 231 232err: 233 setState(Volume::State_Idle); 234 return ret; 235} 236 237bool Volume::isMountpointMounted(const char *path) { 238 char device[256]; 239 char mount_path[256]; 240 char rest[256]; 241 FILE *fp; 242 char line[1024]; 243 244 if (!(fp = fopen("/proc/mounts", "r"))) { 245 SLOGE("Error opening /proc/mounts (%s)", strerror(errno)); 246 return false; 247 } 248 249 while(fgets(line, sizeof(line), fp)) { 250 line[strlen(line)-1] = '\0'; 251 sscanf(line, "%255s %255s %255s\n", device, mount_path, rest); 252 if (!strcmp(mount_path, path)) { 253 fclose(fp); 254 return true; 255 } 256 257 } 258 259 fclose(fp); 260 return false; 261} 262 263int Volume::mountVol() { 264 dev_t deviceNodes[4]; 265 int n, i, rc = 0; 266 char errmsg[255]; 267 268 if (getState() == Volume::State_NoMedia) { 269 snprintf(errmsg, sizeof(errmsg), 270 "Volume %s %s mount failed - no media", 271 getLabel(), getMountpoint()); 272 mVm->getBroadcaster()->sendBroadcast( 273 ResponseCode::VolumeMountFailedNoMedia, 274 errmsg, false); 275 errno = ENODEV; 276 return -1; 277 } else if (getState() != Volume::State_Idle) { 278 errno = EBUSY; 279 return -1; 280 } 281 282 if (isMountpointMounted(getMountpoint())) { 283 SLOGW("Volume is idle but appears to be mounted - fixing"); 284 setState(Volume::State_Mounted); 285 // mCurrentlyMountedKdev = XXX 286 return 0; 287 } 288 289 n = getDeviceNodes((dev_t *) &deviceNodes, 4); 290 if (!n) { 291 SLOGE("Failed to get device nodes (%s)\n", strerror(errno)); 292 return -1; 293 } 294 295 for (i = 0; i < n; i++) { 296 char devicePath[255]; 297 298 sprintf(devicePath, "/dev/block/vold/%d:%d", MAJOR(deviceNodes[i]), 299 MINOR(deviceNodes[i])); 300 301 SLOGI("%s being considered for volume %s\n", devicePath, getLabel()); 302 303 errno = 0; 304 setState(Volume::State_Checking); 305 306 if (Fat::check(devicePath)) { 307 if (errno == ENODATA) { 308 SLOGW("%s does not contain a FAT filesystem\n", devicePath); 309 continue; 310 } 311 errno = EIO; 312 /* Badness - abort the mount */ 313 SLOGE("%s failed FS checks (%s)", devicePath, strerror(errno)); 314 setState(Volume::State_Idle); 315 return -1; 316 } 317 318 /* 319 * Mount the device on our internal staging mountpoint so we can 320 * muck with it before exposing it to non priviledged users. 321 */ 322 errno = 0; 323 if (Fat::doMount(devicePath, "/mnt/secure/staging", false, false, 1000, 1015, 0702, true)) { 324 SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno)); 325 continue; 326 } 327 328 SLOGI("Device %s, target %s mounted @ /mnt/secure/staging", devicePath, getMountpoint()); 329 330 protectFromAutorunStupidity(); 331 332 if (createBindMounts()) { 333 SLOGE("Failed to create bindmounts (%s)", strerror(errno)); 334 umount("/mnt/secure/staging"); 335 setState(Volume::State_Idle); 336 return -1; 337 } 338 339 /* 340 * Now that the bindmount trickery is done, atomically move the 341 * whole subtree to expose it to non priviledged users. 342 */ 343 if (doMoveMount("/mnt/secure/staging", getMountpoint(), false)) { 344 SLOGE("Failed to move mount (%s)", strerror(errno)); 345 umount("/mnt/secure/staging"); 346 setState(Volume::State_Idle); 347 return -1; 348 } 349 setState(Volume::State_Mounted); 350 mCurrentlyMountedKdev = deviceNodes[i]; 351 return 0; 352 } 353 354 SLOGE("Volume %s found no suitable devices for mounting :(\n", getLabel()); 355 setState(Volume::State_Idle); 356 357 return -1; 358} 359 360int Volume::createBindMounts() { 361 unsigned long flags; 362 363 /* 364 * Rename old /android_secure -> /.android_secure 365 */ 366 if (!access("/mnt/secure/staging/android_secure", R_OK | X_OK) && 367 access(SEC_STG_SECIMGDIR, R_OK | X_OK)) { 368 if (rename("/mnt/secure/staging/android_secure", SEC_STG_SECIMGDIR)) { 369 SLOGE("Failed to rename legacy asec dir (%s)", strerror(errno)); 370 } 371 } 372 373 /* 374 * Ensure that /android_secure exists and is a directory 375 */ 376 if (access(SEC_STG_SECIMGDIR, R_OK | X_OK)) { 377 if (errno == ENOENT) { 378 if (mkdir(SEC_STG_SECIMGDIR, 0777)) { 379 SLOGE("Failed to create %s (%s)", SEC_STG_SECIMGDIR, strerror(errno)); 380 return -1; 381 } 382 } else { 383 SLOGE("Failed to access %s (%s)", SEC_STG_SECIMGDIR, strerror(errno)); 384 return -1; 385 } 386 } else { 387 struct stat sbuf; 388 389 if (stat(SEC_STG_SECIMGDIR, &sbuf)) { 390 SLOGE("Failed to stat %s (%s)", SEC_STG_SECIMGDIR, strerror(errno)); 391 return -1; 392 } 393 if (!S_ISDIR(sbuf.st_mode)) { 394 SLOGE("%s is not a directory", SEC_STG_SECIMGDIR); 395 errno = ENOTDIR; 396 return -1; 397 } 398 } 399 400 /* 401 * Bind mount /mnt/secure/staging/android_secure -> /mnt/secure/asec so we'll 402 * have a root only accessable mountpoint for it. 403 */ 404 if (mount(SEC_STG_SECIMGDIR, SEC_ASECDIR, "", MS_BIND, NULL)) { 405 SLOGE("Failed to bind mount points %s -> %s (%s)", 406 SEC_STG_SECIMGDIR, SEC_ASECDIR, strerror(errno)); 407 return -1; 408 } 409 410 /* 411 * Mount a read-only, zero-sized tmpfs on <mountpoint>/android_secure to 412 * obscure the underlying directory from everybody - sneaky eh? ;) 413 */ 414 if (mount("tmpfs", SEC_STG_SECIMGDIR, "tmpfs", MS_RDONLY, "size=0,mode=000,uid=0,gid=0")) { 415 SLOGE("Failed to obscure %s (%s)", SEC_STG_SECIMGDIR, strerror(errno)); 416 umount("/mnt/asec_secure"); 417 return -1; 418 } 419 420 return 0; 421} 422 423int Volume::doMoveMount(const char *src, const char *dst, bool force) { 424 unsigned int flags = MS_MOVE; 425 int retries = 5; 426 427 while(retries--) { 428 if (!mount(src, dst, "", flags, NULL)) { 429 if (mDebug) { 430 SLOGD("Moved mount %s -> %s sucessfully", src, dst); 431 } 432 return 0; 433 } else if (errno != EBUSY) { 434 SLOGE("Failed to move mount %s -> %s (%s)", src, dst, strerror(errno)); 435 return -1; 436 } 437 int action = 0; 438 439 if (force) { 440 if (retries == 1) { 441 action = 2; // SIGKILL 442 } else if (retries == 2) { 443 action = 1; // SIGHUP 444 } 445 } 446 SLOGW("Failed to move %s -> %s (%s, retries %d, action %d)", 447 src, dst, strerror(errno), retries, action); 448 Process::killProcessesWithOpenFiles(src, action); 449 usleep(1000*250); 450 } 451 452 errno = EBUSY; 453 SLOGE("Giving up on move %s -> %s (%s)", src, dst, strerror(errno)); 454 return -1; 455} 456 457int Volume::doUnmount(const char *path, bool force) { 458 int retries = 10; 459 460 if (mDebug) { 461 SLOGD("Unmounting {%s}, force = %d", path, force); 462 } 463 464 while (retries--) { 465 if (!umount(path) || errno == EINVAL || errno == ENOENT) { 466 SLOGI("%s sucessfully unmounted", path); 467 return 0; 468 } 469 470 int action = 0; 471 472 if (force) { 473 if (retries == 1) { 474 action = 2; // SIGKILL 475 } else if (retries == 2) { 476 action = 1; // SIGHUP 477 } 478 } 479 480 SLOGW("Failed to unmount %s (%s, retries %d, action %d)", 481 path, strerror(errno), retries, action); 482 483 Process::killProcessesWithOpenFiles(path, action); 484 usleep(1000*1000); 485 } 486 errno = EBUSY; 487 SLOGE("Giving up on unmount %s (%s)", path, strerror(errno)); 488 return -1; 489} 490 491int Volume::unmountVol(bool force) { 492 int i, rc; 493 494 if (getState() != Volume::State_Mounted) { 495 SLOGE("Volume %s unmount request when not mounted", getLabel()); 496 errno = EINVAL; 497 return -1; 498 } 499 500 setState(Volume::State_Unmounting); 501 usleep(1000 * 1000); // Give the framework some time to react 502 503 /* 504 * First move the mountpoint back to our internal staging point 505 * so nobody else can muck with it while we work. 506 */ 507 if (doMoveMount(getMountpoint(), SEC_STGDIR, force)) { 508 SLOGE("Failed to move mount %s => %s (%s)", getMountpoint(), SEC_STGDIR, strerror(errno)); 509 setState(Volume::State_Mounted); 510 return -1; 511 } 512 513 protectFromAutorunStupidity(); 514 515 /* 516 * Unmount the tmpfs which was obscuring the asec image directory 517 * from non root users 518 */ 519 520 if (doUnmount(Volume::SEC_STG_SECIMGDIR, force)) { 521 SLOGE("Failed to unmount tmpfs on %s (%s)", SEC_STG_SECIMGDIR, strerror(errno)); 522 goto fail_republish; 523 } 524 525 /* 526 * Remove the bindmount we were using to keep a reference to 527 * the previously obscured directory. 528 */ 529 530 if (doUnmount(Volume::SEC_ASECDIR, force)) { 531 SLOGE("Failed to remove bindmount on %s (%s)", SEC_ASECDIR, strerror(errno)); 532 goto fail_remount_tmpfs; 533 } 534 535 /* 536 * Finally, unmount the actual block device from the staging dir 537 */ 538 if (doUnmount(Volume::SEC_STGDIR, force)) { 539 SLOGE("Failed to unmount %s (%s)", SEC_STGDIR, strerror(errno)); 540 goto fail_recreate_bindmount; 541 } 542 543 SLOGI("%s unmounted sucessfully", getMountpoint()); 544 545 setState(Volume::State_Idle); 546 mCurrentlyMountedKdev = -1; 547 return 0; 548 549 /* 550 * Failure handling - try to restore everything back the way it was 551 */ 552fail_recreate_bindmount: 553 if (mount(SEC_STG_SECIMGDIR, SEC_ASECDIR, "", MS_BIND, NULL)) { 554 SLOGE("Failed to restore bindmount after failure! - Storage will appear offline!"); 555 goto out_nomedia; 556 } 557fail_remount_tmpfs: 558 if (mount("tmpfs", SEC_STG_SECIMGDIR, "tmpfs", MS_RDONLY, "size=0,mode=0,uid=0,gid=0")) { 559 SLOGE("Failed to restore tmpfs after failure! - Storage will appear offline!"); 560 goto out_nomedia; 561 } 562fail_republish: 563 if (doMoveMount(SEC_STGDIR, getMountpoint(), force)) { 564 SLOGE("Failed to republish mount after failure! - Storage will appear offline!"); 565 goto out_nomedia; 566 } 567 568 setState(Volume::State_Mounted); 569 return -1; 570 571out_nomedia: 572 setState(Volume::State_NoMedia); 573 return -1; 574} 575 576int Volume::initializeMbr(const char *deviceNode) { 577 struct disk_info dinfo; 578 579 memset(&dinfo, 0, sizeof(dinfo)); 580 581 if (!(dinfo.part_lst = (struct part_info *) malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) { 582 SLOGE("Failed to malloc prt_lst"); 583 return -1; 584 } 585 586 memset(dinfo.part_lst, 0, MAX_NUM_PARTS * sizeof(struct part_info)); 587 dinfo.device = strdup(deviceNode); 588 dinfo.scheme = PART_SCHEME_MBR; 589 dinfo.sect_size = 512; 590 dinfo.skip_lba = 2048; 591 dinfo.num_lba = 0; 592 dinfo.num_parts = 1; 593 594 struct part_info *pinfo = &dinfo.part_lst[0]; 595 596 pinfo->name = strdup("android_sdcard"); 597 pinfo->flags |= PART_ACTIVE_FLAG; 598 pinfo->type = PC_PART_TYPE_FAT32; 599 pinfo->len_kb = -1; 600 601 int rc = apply_disk_config(&dinfo, 0); 602 603 if (rc) { 604 SLOGE("Failed to apply disk configuration (%d)", rc); 605 goto out; 606 } 607 608 out: 609 free(pinfo->name); 610 free(dinfo.device); 611 free(dinfo.part_lst); 612 613 return rc; 614} 615